diff --git a/runtime/BUILD.gn b/runtime/BUILD.gn index 3060b33e65e..90dfa343e31 100644 --- a/runtime/BUILD.gn +++ b/runtime/BUILD.gn @@ -172,6 +172,10 @@ config("dart_config") { defines += [ "SUPPORT_PERFETTO" ] } + if (dart_dynamic_modules) { + defines += [ "DART_DYNAMIC_MODULES" ] + } + if (is_fuchsia) { lib_dirs = [ "${fuchsia_arch_root}/lib" ] diff --git a/runtime/lib/errors.cc b/runtime/lib/errors.cc index 58ec67ce890..bf194e5c60a 100644 --- a/runtime/lib/errors.cc +++ b/runtime/lib/errors.cc @@ -31,21 +31,25 @@ static ScriptPtr FindScript(DartFrameIterator* iterator) { ASSERT(!assert_error_class.IsNull()); bool hit_assertion_error = false; for (; stack_frame != nullptr; stack_frame = iterator->NextFrame()) { - code = stack_frame->LookupDartCode(); - if (code.is_optimized()) { - InlinedFunctionsIterator inlined_iterator(code, stack_frame->pc()); - while (!inlined_iterator.Done()) { - func = inlined_iterator.function(); - if (hit_assertion_error) { - return func.script(); - } - ASSERT(!hit_assertion_error); - hit_assertion_error = (func.Owner() == assert_error_class.ptr()); - inlined_iterator.Advance(); - } - continue; + if (stack_frame->is_interpreted()) { + func = stack_frame->LookupDartFunction(); } else { - func = code.function(); + code = stack_frame->LookupDartCode(); + if (code.is_optimized()) { + InlinedFunctionsIterator inlined_iterator(code, stack_frame->pc()); + while (!inlined_iterator.Done()) { + func = inlined_iterator.function(); + if (hit_assertion_error) { + return func.script(); + } + ASSERT(!hit_assertion_error); + hit_assertion_error = (func.Owner() == assert_error_class.ptr()); + inlined_iterator.Advance(); + } + continue; + } else { + func = code.function(); + } } ASSERT(!func.IsNull()); if (hit_assertion_error) { diff --git a/runtime/lib/object.cc b/runtime/lib/object.cc index eeb3f641882..0cc3a733340 100644 --- a/runtime/lib/object.cc +++ b/runtime/lib/object.cc @@ -5,6 +5,7 @@ #include "vm/bootstrap_natives.h" #include "lib/invocation_mirror.h" +#include "vm/bytecode_reader.h" #include "vm/code_patcher.h" #include "vm/dart_entry.h" #include "vm/exceptions.h" @@ -560,6 +561,61 @@ DEFINE_NATIVE_ENTRY(Internal_boundsCheckForPartialInstantiation, 0, 2) { return Object::null(); } +DEFINE_NATIVE_ENTRY(Internal_loadDynamicModule, 0, 1) { +#if defined(DART_DYNAMIC_MODULES) + GET_NON_NULL_NATIVE_ARGUMENT(TypedData, module_bytes, + arguments->NativeArgAt(0)); + + const intptr_t length = module_bytes.LengthInBytes(); + uint8_t* data = reinterpret_cast(::malloc(length)); + if (data == nullptr) { + const auto& exception = Instance::Handle( + zone, thread->isolate_group()->object_store()->out_of_memory()); + Exceptions::Throw(thread, exception); + } + { + NoSafepointScope no_safepoint; + // The memory does not overlap. + memcpy(data, module_bytes.DataAddr(0), length); // NOLINT + } + const ExternalTypedData& typed_data = ExternalTypedData::Handle( + zone, + ExternalTypedData::New(kExternalTypedDataUint8ArrayCid, data, length)); + auto& function = Function::Handle(); + { + SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock()); + bytecode::BytecodeLoader loader(thread, typed_data); + function = loader.LoadBytecode(); + } + + if (function.IsNull()) { + return Object::null(); + } + ASSERT(function.is_static()); + ASSERT(function.is_declared_in_bytecode()); + auto& result = Object::Handle(zone); + if (function.NumParameters() == 0) { + result = DartEntry::InvokeFunction(function, Object::empty_array()); + } else { + ASSERT(function.NumParameters() == 1); + // [] + const auto& arg0 = Array::Handle( + zone, Array::New(0, Type::Handle(zone, Type::StringType()))); + const auto& args = Array::Handle(zone, Array::New(1)); + args.SetAt(0, arg0); + result = DartEntry::InvokeFunction(function, args); + } + if (result.IsError()) { + Exceptions::PropagateError(Error::Cast(result)); + } + return result.ptr(); +#else + Exceptions::ThrowUnsupportedError( + "Loading of dynamic modules is not supported."); + return Object::null(); +#endif // defined(DART_DYNAMIC_MODULES) +} + DEFINE_NATIVE_ENTRY(InvocationMirror_unpackTypeArguments, 0, 2) { const TypeArguments& type_arguments = TypeArguments::CheckedHandle(zone, arguments->NativeArgAt(0)); diff --git a/runtime/lib/stacktrace.cc b/runtime/lib/stacktrace.cc index e06212e9c1b..4f385959470 100644 --- a/runtime/lib/stacktrace.cc +++ b/runtime/lib/stacktrace.cc @@ -46,7 +46,11 @@ static StackTracePtr CurrentStackTrace(Thread* thread, // Collect the frames. StackTraceUtils::CollectFrames(thread, skip_frames, [&](const StackTraceUtils::Frame& frame) { - code_array.Add(frame.code); + if (!frame.bytecode.IsNull()) { + code_array.Add(frame.bytecode); + } else { + code_array.Add(frame.code); + } pc_offset_array.Add(frame.pc_offset); }); @@ -72,6 +76,7 @@ static void AppendFrames(const GrowableObjectArray& code_list, StackFrame* frame = frames.NextFrame(); ASSERT(frame != nullptr); // We expect to find a dart invocation frame. Code& code = Code::Handle(zone); + Bytecode& bytecode = Bytecode::Handle(zone); for (; frame != nullptr; frame = frames.NextFrame()) { if (!frame->IsDartFrame()) { continue; @@ -81,10 +86,20 @@ static void AppendFrames(const GrowableObjectArray& code_list, continue; } - code = frame->LookupDartCode(); - const intptr_t pc_offset = frame->pc() - code.PayloadStart(); - code_list.Add(code); - pc_offset_list->Add(pc_offset); + if (frame->is_interpreted()) { + bytecode = frame->LookupDartBytecode(); + if (bytecode.function() == Function::null()) { + continue; + } + const intptr_t pc_offset = frame->pc() - bytecode.PayloadStart(); + code_list.Add(bytecode); + pc_offset_list->Add(pc_offset); + } else { + code = frame->LookupDartCode(); + const intptr_t pc_offset = frame->pc() - code.PayloadStart(); + code_list.Add(code); + pc_offset_list->Add(pc_offset); + } } } diff --git a/runtime/runtime_args.gni b/runtime/runtime_args.gni index dc10b71b7d6..e9adc042cc0 100644 --- a/runtime/runtime_args.gni +++ b/runtime/runtime_args.gni @@ -74,6 +74,9 @@ declare_args() { # being built on platforms which have a problem linking in the Perfetto # library. dart_support_perfetto = true + + # Whether to support dynamic loading and interpretation of Dart bytecode. + dart_dynamic_modules = false } declare_args() { diff --git a/runtime/vm/app_snapshot.cc b/runtime/vm/app_snapshot.cc index 1a1ee2f772f..b65edb63f82 100644 --- a/runtime/vm/app_snapshot.cc +++ b/runtime/vm/app_snapshot.cc @@ -1702,7 +1702,7 @@ class FunctionSerializationCluster : public SerializationCluster { } else if (kind == Snapshot::kFullJIT) { NOT_IN_PRECOMPILED(s->Push(func->untag()->unoptimized_code())); s->Push(func->untag()->code()); - s->Push(func->untag()->ic_data_array()); + s->Push(func->untag()->ic_data_array_or_bytecode()); } if (kind != Snapshot::kFullAOT) { NOT_IN_PRECOMPILED(s->Push(func->untag()->positional_parameter_names())); @@ -1737,7 +1737,7 @@ class FunctionSerializationCluster : public SerializationCluster { } else if (s->kind() == Snapshot::kFullJIT) { NOT_IN_PRECOMPILED(WriteCompressedField(func, unoptimized_code)); WriteCompressedField(func, code); - WriteCompressedField(func, ic_data_array); + WriteCompressedField(func, ic_data_array_or_bytecode); } if (kind != Snapshot::kFullAOT) { @@ -1917,7 +1917,7 @@ class FunctionDeserializationCluster : public DeserializationCluster { if (kind == Snapshot::kFullJIT) { func->untag()->unoptimized_code_ = static_cast(d.ReadRef()); func->untag()->code_ = static_cast(d.ReadRef()); - func->untag()->ic_data_array_ = static_cast(d.ReadRef()); + func->untag()->ic_data_array_or_bytecode_ = d.ReadRef(); } #endif diff --git a/runtime/vm/bootstrap_natives.h b/runtime/vm/bootstrap_natives.h index a9fd1583823..b4150b46f6d 100644 --- a/runtime/vm/bootstrap_natives.h +++ b/runtime/vm/bootstrap_natives.h @@ -268,6 +268,7 @@ namespace dart { V(Internal_extractTypeArguments, 2) \ V(Internal_prependTypeArguments, 4) \ V(Internal_boundsCheckForPartialInstantiation, 2) \ + V(Internal_loadDynamicModule, 1) \ V(Internal_allocateOneByteString, 1) \ V(Internal_allocateTwoByteString, 1) \ V(Internal_writeIntoOneByteString, 3) \ diff --git a/runtime/vm/bytecode_reader.cc b/runtime/vm/bytecode_reader.cc new file mode 100644 index 00000000000..05a996441b3 --- /dev/null +++ b/runtime/vm/bytecode_reader.cc @@ -0,0 +1,2429 @@ +// Copyright (c) 2024, 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/bytecode_reader.h" + +#include "vm/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/bit_vector.h" +#include "vm/bootstrap.h" +#include "vm/class_finalizer.h" +#include "vm/class_id.h" +#include "vm/closure_functions_cache.h" +#include "vm/code_descriptors.h" +#include "vm/compiler/api/deopt_id.h" +#include "vm/compiler/assembler/disassembler_kbc.h" +#include "vm/constants_kbc.h" +#include "vm/dart_entry.h" +#include "vm/flags.h" +#include "vm/hash.h" +#include "vm/hash_table.h" +#include "vm/longjump.h" +#include "vm/object_store.h" +#include "vm/resolver.h" +#include "vm/reusable_handles.h" +#include "vm/stack_frame_kbc.h" +#include "vm/symbols.h" +#include "vm/timeline.h" + +#define Z (zone_) +#define IG (thread_->isolate_group()) + +namespace dart { + +DEFINE_FLAG(bool, dump_kernel_bytecode, false, "Dump kernel bytecode"); + +namespace bytecode { + +class BytecodeOffsetsMapTraits { + public: + static const char* Name() { return "BytecodeOffsetsMapTraits"; } + static bool ReportStats() { return false; } + + static bool IsMatch(const Object& a, const Object& b) { + return (a.ptr() == b.ptr()); + } + + static uword Hash(const Object& key) { + if (key.IsClass()) { + return Class::Cast(key).id(); + } else if (key.IsFunction()) { + return Function::Cast(key).Hash(); + } else if (key.IsField()) { + return Field::Cast(key).Hash(); + } else { + UNREACHABLE(); + } + } +}; +using BytecodeOffsetsMap = UnorderedHashMap; + +BytecodeLoader::BytecodeLoader(Thread* thread, const TypedDataBase& binary) + : thread_(thread), + binary_(binary), + bytecode_component_array_(Array::Handle(thread->zone())), + bytecode_offsets_map_( + Array::Handle(thread->zone(), + HashTables::New(16))) { + ASSERT(thread_ == Thread::Current()); + ASSERT(thread_->bytecode_loader() == nullptr); + thread_->set_bytecode_loader(this); + + ASSERT(!binary_.IsNull()); + ASSERT(binary_.IsExternalOrExternalView()); +} + +BytecodeLoader::~BytecodeLoader() { + ASSERT(thread_->bytecode_loader() == this); + thread_->set_bytecode_loader(nullptr); +} + +FunctionPtr BytecodeLoader::LoadBytecode() { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + + BytecodeReaderHelper component_reader(thread_, binary_); + bytecode_component_array_ = component_reader.ReadBytecodeComponent(); + + BytecodeComponentData bytecode_component(bytecode_component_array_); + BytecodeReaderHelper bytecode_reader(thread_, &bytecode_component); + AlternativeReadingScope alt(&bytecode_reader.reader(), + bytecode_component.GetLibraryIndexOffset()); + bytecode_reader.ReadLibraryDeclarations(bytecode_component.GetNumLibraries()); + + if (bytecode_component.GetMainOffset() == 0) { + return Function::null(); + } + + AlternativeReadingScope alt2(&bytecode_reader.reader(), + bytecode_component.GetMainOffset()); + return Function::RawCast(bytecode_reader.ReadObject()); +} + +void BytecodeLoader::SetOffset(const Object& obj, intptr_t offset) { + BytecodeOffsetsMap map(bytecode_offsets_map_.ptr()); + map.UpdateOrInsert(obj, Smi::Handle(thread_->zone(), Smi::New(offset))); + bytecode_offsets_map_ = map.Release().ptr(); +} + +intptr_t BytecodeLoader::GetOffset(const Object& obj) { + BytecodeOffsetsMap map(bytecode_offsets_map_.ptr()); + const auto value = map.GetOrNull(obj); + ASSERT(value != Object::null()); + const intptr_t offset = Smi::Value(Smi::RawCast(value)); + ASSERT(map.Release().ptr() == bytecode_offsets_map_.ptr()); + return offset; +} + +BytecodeReaderHelper::BytecodeReaderHelper(Thread* thread, + const TypedDataBase& typed_data) + : reader_(typed_data), + thread_(thread), + zone_(thread->zone()), + bytecode_component_(nullptr), + scoped_function_(Function::Handle(thread->zone())), + scoped_function_name_(String::Handle(thread->zone())), + scoped_function_class_(Class::Handle(thread->zone())) {} + +BytecodeReaderHelper::BytecodeReaderHelper( + Thread* thread, + BytecodeComponentData* bytecode_component) + : reader_(TypedDataBase::Handle(thread->zone(), + bytecode_component->GetTypedData())), + thread_(thread), + zone_(thread->zone()), + bytecode_component_(bytecode_component), + scoped_function_(Function::Handle(thread->zone())), + scoped_function_name_(String::Handle(thread->zone())), + scoped_function_class_(Class::Handle(thread->zone())) {} + +void BytecodeReaderHelper::ReadCode(const Function& function, + intptr_t code_offset) { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + ASSERT(!function.IsImplicitGetterFunction() && + !function.IsImplicitSetterFunction()); + if (code_offset == 0) { + FATAL("Function %s (kind %s) doesn't have bytecode", + function.ToFullyQualifiedCString(), + Function::KindToCString(function.kind())); + } + + AlternativeReadingScope alt(&reader_, code_offset); + const auto& signature = FunctionType::Handle(Z, function.signature()); + FunctionTypeScope function_type_scope(this, signature); + + const intptr_t flags = reader_.ReadUInt(); + const bool has_exceptions_table = + (flags & Code::kHasExceptionsTableFlag) != 0; + const bool has_source_positions = + (flags & Code::kHasSourcePositionsFlag) != 0; + const bool has_local_variables = (flags & Code::kHasLocalVariablesFlag) != 0; + const bool has_nullable_fields = (flags & Code::kHasNullableFieldsFlag) != 0; + const bool has_closures = (flags & Code::kHasClosuresFlag) != 0; + const bool has_parameter_flags = (flags & Code::kHasParameterFlagsFlag) != 0; + const bool has_forwarding_stub_target = + (flags & Code::kHasForwardingStubTargetFlag) != 0; + const bool has_default_function_type_args = + (flags & Code::kHasDefaultFunctionTypeArgsFlag) != 0; + + if (has_parameter_flags) { + intptr_t num_flags = reader_.ReadUInt(); + for (intptr_t i = 0; i < num_flags; ++i) { + reader_.ReadUInt(); + } + } + if (has_forwarding_stub_target) { + reader_.ReadUInt(); + } + if (has_default_function_type_args) { + reader_.ReadUInt(); + } + + intptr_t num_closures = 0; + if (has_closures) { + num_closures = reader_.ReadListLength(); + closures_ = &Array::Handle(Z, Array::New(num_closures)); + for (intptr_t i = 0; i < num_closures; i++) { + ReadClosureDeclaration(function, i); + } + } + + // Create object pool and read pool entries. + const intptr_t obj_count = reader_.ReadListLength(); + const ObjectPool& pool = ObjectPool::Handle(Z, ObjectPool::New(obj_count)); + ReadConstantPool(function, pool, 0); + + // Read bytecode and attach to function. + const Bytecode& bytecode = Bytecode::Handle(Z, ReadBytecode(pool)); + bytecode.set_code_offset(code_offset); + function.AttachBytecode(bytecode); + + ReadExceptionsTable(function, bytecode, has_exceptions_table); + + ReadSourcePositions(bytecode, has_source_positions); + + ReadLocalVariables(bytecode, has_local_variables); + + if (FLAG_dump_kernel_bytecode) { + KernelBytecodeDisassembler::Disassemble(function); + } + + // Initialization of fields with null literal is elided from bytecode. + // Record the corresponding stores if field guards are enabled. + if (has_nullable_fields) { + ASSERT(function.IsGenerativeConstructor()); + const intptr_t num_fields = reader_.ReadListLength(); + if (IG->use_field_guards()) { + Field& field = Field::Handle(Z); + for (intptr_t i = 0; i < num_fields; i++) { + field ^= ReadObject(); + field.RecordStore(Object::null_object()); + } + } else { + for (intptr_t i = 0; i < num_fields; i++) { + ReadObject(); + } + } + } + + // Read closures. + if (has_closures) { + Function& closure = Function::Handle(Z); + Bytecode& closure_bytecode = Bytecode::Handle(Z); + for (intptr_t i = 0; i < num_closures; i++) { + closure ^= closures_->At(i); + + const intptr_t flags = reader_.ReadUInt(); + const bool has_exceptions_table = + (flags & ClosureCode::kHasExceptionsTableFlag) != 0; + const bool has_source_positions = + (flags & ClosureCode::kHasSourcePositionsFlag) != 0; + const bool has_local_variables = + (flags & ClosureCode::kHasLocalVariablesFlag) != 0; + + // Read closure bytecode and attach to closure function. + closure_bytecode = ReadBytecode(pool); + closure.AttachBytecode(closure_bytecode); + + ReadExceptionsTable(closure, closure_bytecode, has_exceptions_table); + + ReadSourcePositions(closure_bytecode, has_source_positions); + + ReadLocalVariables(closure_bytecode, has_local_variables); + + if (FLAG_dump_kernel_bytecode) { + KernelBytecodeDisassembler::Disassemble(closure); + } + } + } +} + +void BytecodeReaderHelper::ReadClosureDeclaration(const Function& function, + intptr_t closureIndex) { + // Closure flags, must be in sync with ClosureDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + const int kHasOptionalPositionalParamsFlag = 1 << 0; + const int kHasOptionalNamedParamsFlag = 1 << 1; + const int kHasTypeParamsFlag = 1 << 2; + const int kHasSourcePositionsFlag = 1 << 3; + const int kIsAsyncFlag = 1 << 4; + const int kIsAsyncStarFlag = 1 << 5; + const int kIsSyncStarFlag = 1 << 6; + const int kIsDebuggableFlag = 1 << 7; + const int kHasParameterFlagsFlag = 1 << 8; + + const intptr_t flags = reader_.ReadUInt(); + + Object& parent = Object::Handle(Z, ReadObject()); + if (!parent.IsFunction()) { + ASSERT(parent.IsField()); + ASSERT(function.kind() == UntaggedFunction::kFieldInitializer); + // Closure in a static field initializer, so use current function as parent. + parent = function.ptr(); + } + + String& name = String::CheckedHandle(Z, ReadObject()); + ASSERT(name.IsSymbol()); + + TokenPosition position = TokenPosition::kNoSource; + TokenPosition end_position = TokenPosition::kNoSource; + if ((flags & kHasSourcePositionsFlag) != 0) { + position = reader_.ReadPosition(); + end_position = reader_.ReadPosition(); + } + + const Function& closure = Function::Handle( + Z, Function::NewClosureFunction(name, Function::Cast(parent), position)); + + NOT_IN_PRECOMPILED(closure.set_end_token_pos(end_position)); + + if ((flags & kIsSyncStarFlag) != 0) { + closure.set_modifier(UntaggedFunction::kSyncGen); + closure.set_is_inlinable(false); + } else if ((flags & kIsAsyncFlag) != 0) { + closure.set_modifier(UntaggedFunction::kAsync); + closure.set_is_inlinable(false); + } else if ((flags & kIsAsyncStarFlag) != 0) { + closure.set_modifier(UntaggedFunction::kAsyncGen); + closure.set_is_inlinable(false); + } + closure.set_is_debuggable((flags & kIsDebuggableFlag) != 0); + + closures_->SetAt(closureIndex, closure); + + auto& signature = FunctionType::Handle(Z, closure.signature()); + signature = ReadFunctionSignature( + signature, (flags & kHasOptionalPositionalParamsFlag) != 0, + (flags & kHasOptionalNamedParamsFlag) != 0, + (flags & kHasTypeParamsFlag) != 0, + /* has_positional_param_names = */ true, + (flags & kHasParameterFlagsFlag) != 0); + + closure.SetSignature(signature); +} + +FunctionTypePtr BytecodeReaderHelper::ReadFunctionSignature( + const FunctionType& signature, + bool has_optional_positional_params, + bool has_optional_named_params, + bool has_type_params, + bool has_positional_param_names, + bool has_parameter_flags) { + FunctionTypeScope function_type_scope(this, signature); + + if (has_type_params) { + ReadTypeParametersDeclaration(Class::Handle(Z), signature); + } + + const intptr_t kImplicitClosureParam = 1; + const intptr_t num_params = kImplicitClosureParam + reader_.ReadUInt(); + + intptr_t num_required_params = num_params; + if (has_optional_positional_params || has_optional_named_params) { + num_required_params = kImplicitClosureParam + reader_.ReadUInt(); + } + + signature.set_num_fixed_parameters(num_required_params); + signature.SetNumOptionalParameters(num_params - num_required_params, + !has_optional_named_params); + signature.set_parameter_types( + Array::Handle(Z, Array::New(num_params, Heap::kOld))); + signature.CreateNameArrayIncludingFlags(Heap::kOld); + + intptr_t i = 0; + signature.SetParameterTypeAt(i, AbstractType::dynamic_type()); + ++i; + + AbstractType& type = AbstractType::Handle(Z); + String& name = String::Handle(Z); + for (; i < num_params; ++i) { + if (has_positional_param_names || + (has_optional_named_params && (i >= num_required_params))) { + name ^= ReadObject(); + if (has_optional_named_params && (i >= num_required_params)) { + signature.SetParameterNameAt(i, name); + } + } + type ^= ReadObject(); + signature.SetParameterTypeAt(i, type); + } + if (has_parameter_flags) { + intptr_t num_flags = reader_.ReadUInt(); + for (intptr_t i = 0; i < num_flags; ++i) { + intptr_t flag = reader_.ReadUInt(); + if ((flag & Parameter::kIsRequiredFlag) != 0) { + RELEASE_ASSERT(kImplicitClosureParam + i >= num_required_params); + signature.SetIsRequiredAt(kImplicitClosureParam + i); + } + } + } + + type ^= ReadObject(); + signature.set_result_type(type); + + // Finalize function type. + return FunctionType::RawCast( + ClassFinalizer::FinalizeType(signature, ClassFinalizer::kCanonicalize)); +} + +void BytecodeReaderHelper::ReadTypeParametersDeclaration( + const Class& parameterized_class, + const FunctionType& parameterized_signature) { + ASSERT(parameterized_class.IsNull() != parameterized_signature.IsNull()); + + const intptr_t num_type_params = reader_.ReadUInt(); + ASSERT(num_type_params > 0); + + // First setup the type parameters, so if any of the following code uses it + // (in a recursive way) we're fine. + // + // Step a) Create TypeParameters object (without bounds and defaults). + const TypeParameters& type_parameters = + TypeParameters::Handle(Z, TypeParameters::New(num_type_params)); + + if (!parameterized_class.IsNull()) { + ASSERT(parameterized_class.type_parameters() == TypeParameters::null()); + parameterized_class.set_type_parameters(type_parameters); + } else { + ASSERT(parameterized_signature.type_parameters() == TypeParameters::null()); + parameterized_signature.SetTypeParameters(type_parameters); + } + + String& name = String::Handle(Z); + AbstractType& type = AbstractType::Handle(Z); + for (intptr_t i = 0; i < num_type_params; ++i) { + name ^= ReadObject(); + ASSERT(name.IsSymbol()); + type_parameters.SetNameAt(i, name); + // Set bound temporarily to dynamic in order to + // allow type finalization of type parameter types. + type_parameters.SetBoundAt(i, Object::dynamic_type()); + } + + // Step b) Fill in the bounds and defaults of all [TypeParameter]s. + for (intptr_t i = 0; i < num_type_params; ++i) { + type ^= ReadObject(); + type_parameters.SetBoundAt(i, type); + type ^= ReadObject(); + type_parameters.SetDefaultAt(i, type); + } +} + +intptr_t BytecodeReaderHelper::ReadConstantPool(const Function& function, + const ObjectPool& pool, + intptr_t start_index) { + // These enums and the code below reading the constant pool from kernel must + // be kept in sync with pkg/dart2bytecode/lib/constant_pool.dart. + enum ConstantPoolTag { + kInvalid, + kStaticField, + kInstanceField, + kClass, + kTypeArgumentsField, + kType, + kClosureFunction, + kEndClosureFunctionScope, + kSubtypeTestCache, + kEmptyTypeArguments, + kObjectRef, + kDirectCall, + kInterfaceCall, + kInstantiatedInterfaceCall, + kDynamicCall, + }; + + Object& obj = Object::Handle(Z); + Object& elem = Object::Handle(Z); + Field& field = Field::Handle(Z); + Class& cls = Class::Handle(Z); + String& name = String::Handle(Z); + const intptr_t obj_count = pool.Length(); + for (intptr_t i = start_index; i < obj_count; ++i) { + const intptr_t tag = reader_.ReadByte(); + switch (tag) { + case ConstantPoolTag::kInvalid: + UNREACHABLE(); + case ConstantPoolTag::kStaticField: + obj = ReadObject(); + ASSERT(obj.IsField()); + break; + case ConstantPoolTag::kInstanceField: + field ^= ReadObject(); + // InstanceField constant occupies 2 entries. + // The first entry is used for field offset. + obj = Smi::New(field.HostOffset() / kCompressedWordSize); + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + ++i; + ASSERT(i < obj_count); + // The second entry is used for field object. + obj = field.ptr(); + break; + case ConstantPoolTag::kClass: + obj = ReadObject(); + ASSERT(obj.IsClass()); + break; + case ConstantPoolTag::kTypeArgumentsField: + cls ^= ReadObject(); + obj = Smi::New(cls.host_type_arguments_field_offset() / + kCompressedWordSize); + break; + case ConstantPoolTag::kType: + obj = ReadObject(); + ASSERT(obj.IsAbstractType()); + break; + case ConstantPoolTag::kClosureFunction: { + intptr_t closure_index = reader_.ReadUInt(); + obj = closures_->At(closure_index); + ASSERT(obj.IsFunction()); + // Set current entry. + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + + const auto& signature = + FunctionType::Handle(Z, Function::Cast(obj).signature()); + FunctionTypeScope function_type_scope(this, signature); + + // Read constant pool until corresponding EndClosureFunctionScope. + i = ReadConstantPool(function, pool, i + 1); + + // Proceed with the rest of entries. + continue; + } + case ConstantPoolTag::kEndClosureFunctionScope: { + // EndClosureFunctionScope entry is not used and set to null. + obj = Object::null(); + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + return i; + } + case ConstantPoolTag::kSubtypeTestCache: { + obj = SubtypeTestCache::New(SubtypeTestCache::kMaxInputs); + } break; + case ConstantPoolTag::kEmptyTypeArguments: + obj = Object::empty_type_arguments().ptr(); + break; + case ConstantPoolTag::kObjectRef: + obj = ReadObject(); + break; + case ConstantPoolTag::kDirectCall: { + // DirectCall constant occupies 2 entries. + // The first entry is used for target function. + obj = ReadObject(); + ASSERT(obj.IsFunction()); + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + ++i; + ASSERT(i < obj_count); + // The second entry is used for arguments descriptor. + obj = ReadObject(); + } break; + case ConstantPoolTag::kInterfaceCall: { + elem = ReadObject(); + ASSERT(elem.IsFunction()); + // InterfaceCall constant occupies 2 entries. + // The first entry is used for interface target. + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, elem); + ++i; + ASSERT(i < obj_count); + // The second entry is used for arguments descriptor. + obj = ReadObject(); + } break; + case ConstantPoolTag::kInstantiatedInterfaceCall: { + elem = ReadObject(); + ASSERT(elem.IsFunction()); + // InstantiatedInterfaceCall constant occupies 3 entries: + // 1) Interface target. + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, elem); + ++i; + ASSERT(i < obj_count); + // 2) Arguments descriptor. + obj = ReadObject(); + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + ++i; + ASSERT(i < obj_count); + // 3) Static receiver type. + obj = ReadObject(); + } break; + case ConstantPoolTag::kDynamicCall: { + name ^= ReadObject(); + ASSERT(name.IsSymbol()); + // Do not mangle ==: + // * operator == takes an Object so it is either not checked or + // checked at the entry because the parameter is marked covariant, + // neither of those cases require a dynamic invocation forwarder + if (!Field::IsGetterName(name) && + (name.ptr() != Symbols::EqualOperator().ptr())) { + name = Function::CreateDynamicInvocationForwarderName(name); + } + // DynamicCall constant occupies 2 entries: selector and arguments + // descriptor. + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, name); + ++i; + ASSERT(i < obj_count); + // The second entry is used for arguments descriptor. + obj = ReadObject(); + } break; + default: + UNREACHABLE(); + } + pool.SetTypeAt(i, ObjectPool::EntryType::kTaggedObject, + ObjectPool::Patchability::kNotPatchable, + ObjectPool::SnapshotBehavior::kNotSnapshotable); + pool.SetObjectAt(i, obj); + } + + return obj_count - 1; +} + +BytecodePtr BytecodeReaderHelper::ReadBytecode(const ObjectPool& pool) { + const intptr_t size = reader_.ReadUInt(); + const intptr_t offset = reader_.offset(); + + const uint8_t* data = reader_.BufferAt(offset); + reader_.set_offset(offset + size); + + // Create and return bytecode object. + return Bytecode::New(reinterpret_cast(data), size, offset, + *(reader_.typed_data()), pool); +} + +void BytecodeReaderHelper::ReadExceptionsTable(const Function& function, + const Bytecode& bytecode, + bool has_exceptions_table) { + const intptr_t try_block_count = + has_exceptions_table ? reader_.ReadListLength() : 0; + if (try_block_count > 0) { + const ObjectPool& pool = ObjectPool::Handle(Z, bytecode.object_pool()); + AbstractType& handler_type = AbstractType::Handle(Z); + Array& handler_types = Array::Handle(Z); + DescriptorList* pc_descriptors_list = new (Z) DescriptorList(Z); + ExceptionHandlerList* exception_handlers_list = + new (Z) ExceptionHandlerList(function); + + // Encoding of ExceptionsTable is described in + // pkg/dart2bytecode/lib/exceptions.dart. + for (intptr_t try_index = 0; try_index < try_block_count; try_index++) { + intptr_t outer_try_index_plus1 = reader_.ReadUInt(); + intptr_t outer_try_index = outer_try_index_plus1 - 1; + // PcDescriptors are expressed in terms of return addresses. + intptr_t start_pc = + KernelBytecode::BytecodePcToOffset(reader_.ReadUInt(), + /* is_return_address = */ true); + intptr_t end_pc = + KernelBytecode::BytecodePcToOffset(reader_.ReadUInt(), + /* is_return_address = */ true); + intptr_t handler_pc = + KernelBytecode::BytecodePcToOffset(reader_.ReadUInt(), + /* is_return_address = */ false); + uint8_t flags = reader_.ReadByte(); + const uint8_t kFlagNeedsStackTrace = 1 << 0; + const uint8_t kFlagIsSynthetic = 1 << 1; + const bool needs_stacktrace = (flags & kFlagNeedsStackTrace) != 0; + const bool is_generated = (flags & kFlagIsSynthetic) != 0; + intptr_t type_count = reader_.ReadListLength(); + ASSERT(type_count > 0); + handler_types = Array::New(type_count, Heap::kOld); + for (intptr_t i = 0; i < type_count; i++) { + intptr_t type_index = reader_.ReadUInt(); + ASSERT(type_index < pool.Length()); + handler_type ^= pool.ObjectAt(type_index); + handler_types.SetAt(i, handler_type); + } + pc_descriptors_list->AddDescriptor( + UntaggedPcDescriptors::kOther, start_pc, DeoptId::kNone, + TokenPosition::kNoSource, try_index, + UntaggedPcDescriptors::kInvalidYieldIndex); + pc_descriptors_list->AddDescriptor( + UntaggedPcDescriptors::kOther, end_pc, DeoptId::kNone, + TokenPosition::kNoSource, try_index, + UntaggedPcDescriptors::kInvalidYieldIndex); + + // The exception handler keeps a zone handle of the types array, rather + // than a raw pointer. Do not share the handle across iterations to avoid + // clobbering the array. + exception_handlers_list->AddHandler( + try_index, outer_try_index, handler_pc, is_generated, + Array::ZoneHandle(Z, handler_types.ptr()), needs_stacktrace); + } + const PcDescriptors& descriptors = PcDescriptors::Handle( + Z, pc_descriptors_list->FinalizePcDescriptors(bytecode.PayloadStart())); + bytecode.set_pc_descriptors(descriptors); + const ExceptionHandlers& handlers = ExceptionHandlers::Handle( + Z, exception_handlers_list->FinalizeExceptionHandlers( + bytecode.PayloadStart())); + bytecode.set_exception_handlers(handlers); + } else { + bytecode.set_pc_descriptors(Object::empty_descriptors()); + bytecode.set_exception_handlers(Object::empty_exception_handlers()); + } +} + +void BytecodeReaderHelper::ReadSourcePositions(const Bytecode& bytecode, + bool has_source_positions) { + if (!has_source_positions) { + return; + } + + intptr_t offset = reader_.ReadUInt(); + bytecode.set_source_positions_binary_offset( + bytecode_component_->GetSourcePositionsOffset() + offset); +} + +void BytecodeReaderHelper::ReadLocalVariables(const Bytecode& bytecode, + bool has_local_variables) { + if (!has_local_variables) { + return; + } + + reader_.ReadUInt(); // Skip local variables offset. +} + +ArrayPtr BytecodeReaderHelper::ReadBytecodeComponent() { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + + AlternativeReadingScope alt(&reader_, 0); + + const intptr_t start_offset = reader_.offset(); + + intptr_t magic = reader_.ReadUInt32(); + if (magic != KernelBytecode::kMagicValue) { + FATAL("Unexpected Dart bytecode magic %" Px, magic); + } + + const intptr_t version = reader_.ReadUInt32(); + if (version != KernelBytecode::kBytecodeFormatVersion) { + FATAL("Unsupported Dart bytecode format version %" Pd + ". " + "This version of Dart VM supports bytecode format version %" Pd ".", + version, KernelBytecode::kBytecodeFormatVersion); + } + + reader_.ReadUInt32(); // Skip stringTable.numItems + const intptr_t string_table_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip objectTable.numItems + const intptr_t object_table_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip main.numItems + const intptr_t main_offset = start_offset + reader_.ReadUInt32(); + + const intptr_t num_libraries = reader_.ReadUInt32(); + const intptr_t library_index_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip libraries.numItems + const intptr_t libraries_offset = start_offset + reader_.ReadUInt32(); + + const intptr_t num_classes = reader_.ReadUInt32(); + const intptr_t classes_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip members.numItems + const intptr_t members_offset = start_offset + reader_.ReadUInt32(); + + const intptr_t num_codes = reader_.ReadUInt32(); + const intptr_t codes_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip sourcePositions.numItems + const intptr_t source_positions_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip sourceFiles.numItems + const intptr_t source_files_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip lineStarts.numItems + const intptr_t line_starts_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip localVariables.numItems + const intptr_t local_variables_offset = start_offset + reader_.ReadUInt32(); + + reader_.ReadUInt32(); // Skip annotations.numItems + const intptr_t annotations_offset = start_offset + reader_.ReadUInt32(); + + // Read header of string table. + reader_.set_offset(string_table_offset); + const intptr_t num_one_byte_strings = reader_.ReadUInt32(); + const intptr_t num_two_byte_strings = reader_.ReadUInt32(); + const intptr_t strings_contents_offset = + reader_.offset() + (num_one_byte_strings + num_two_byte_strings) * 4; + + // Read header of object table. + reader_.set_offset(object_table_offset); + const intptr_t num_objects = reader_.ReadUInt(); + const intptr_t objects_size = reader_.ReadUInt(); + + // Skip over contents of objects. + const intptr_t objects_contents_offset = reader_.offset(); + const intptr_t object_offsets_offset = objects_contents_offset + objects_size; + reader_.set_offset(object_offsets_offset); + + auto& bytecode_component_array = Array::Handle( + Z, BytecodeComponentData::New( + Z, *(reader_.typed_data()), version, num_objects, + string_table_offset, strings_contents_offset, + object_offsets_offset, objects_contents_offset, main_offset, + num_libraries, library_index_offset, libraries_offset, num_classes, + classes_offset, members_offset, num_codes, codes_offset, + source_positions_offset, source_files_offset, line_starts_offset, + local_variables_offset, annotations_offset, Heap::kOld)); + + BytecodeComponentData bytecode_component(bytecode_component_array); + + // Read object offsets. + Smi& offs = Smi::Handle(Z); + for (intptr_t i = 0; i < num_objects; ++i) { + offs = Smi::New(reader_.ReadUInt()); + bytecode_component.SetObject(i, offs); + } + + return bytecode_component_array.ptr(); +} + +void BytecodeReaderHelper::ResetObjects() { + reader_.set_offset(bytecode_component_->GetObjectOffsetsOffset()); + const intptr_t num_objects = bytecode_component_->GetNumObjects(); + + // Read object offsets. + Smi& offs = Smi::Handle(Z); + for (intptr_t i = 0; i < num_objects; ++i) { + offs = Smi::New(reader_.ReadUInt()); + bytecode_component_->SetObject(i, offs); + } +} + +ObjectPtr BytecodeReaderHelper::ReadObject() { + uint32_t header = reader_.ReadUInt(); + if ((header & kReferenceBit) != 0) { + intptr_t index = header >> kIndexShift; + if (index == 0) { + return Object::null(); + } + ObjectPtr obj = bytecode_component_->GetObject(index); + if (obj->IsHeapObject()) { + return obj; + } + // Object is not loaded yet. + intptr_t offset = bytecode_component_->GetObjectsContentsOffset() + + Smi::Value(Smi::RawCast(obj)); + AlternativeReadingScope alt(&reader_, offset); + header = reader_.ReadUInt(); + + obj = ReadObjectContents(header); + ASSERT(obj->IsHeapObject()); + { + REUSABLE_OBJECT_HANDLESCOPE(thread_); + Object& obj_handle = thread_->ObjectHandle(); + obj_handle = obj; + bytecode_component_->SetObject(index, obj_handle); + } + return obj; + } + + return ReadObjectContents(header); +} + +StringPtr BytecodeReaderHelper::ConstructorName(const Class& cls, + const String& name) { + GrowableHandlePtrArray pieces(Z, 3); + pieces.Add(String::Handle(Z, cls.Name())); + pieces.Add(Symbols::Dot()); + pieces.Add(name); + return Symbols::FromConcatAll(thread_, pieces); +} + +ObjectPtr BytecodeReaderHelper::ReadObjectContents(uint32_t header) { + ASSERT(((header & kReferenceBit) == 0)); + + // Must be in sync with enum ObjectKind in + // pkg/dart2bytecode/lib/object_table.dart. + enum ObjectKind { + kInvalid, + kLibrary, + kClass, + kMember, + kClosure, + kName, + kTypeArguments, + kConstObject, + kArgDesc, + kScript, + kType, + }; + + // Member flags, must be in sync with _MemberHandle constants in + // pkg/dart2bytecode/lib/object_table.dart. + const intptr_t kFlagIsField = kFlagBit0; + const intptr_t kFlagIsConstructor = kFlagBit1; + + // ArgDesc flags, must be in sync with _ArgDescHandle constants in + // pkg/dart2bytecode/lib/object_table.dart. + const int kFlagHasNamedArgs = kFlagBit0; + const int kFlagHasTypeArgs = kFlagBit1; + + // Script flags, must be in sync with _ScriptHandle constants in + // pkg/dart2bytecode/lib/object_table.dart. + const int kFlagHasSourceFile = kFlagBit0; + + // Name flags, must be in sync with _NameHandle constants in + // pkg/dart2bytecode/lib/object_table.dart. + const intptr_t kFlagIsPublic = kFlagBit0; + + const intptr_t kind = (header >> kKindShift) & kKindMask; + const intptr_t flags = header & kFlagsMask; + + switch (kind) { + case kInvalid: + UNREACHABLE(); + break; + case kLibrary: { + String& uri = String::CheckedHandle(Z, ReadObject()); + LibraryPtr library = Library::LookupLibrary(thread_, uri); + if (library == Library::null()) { + FATAL("Unable to find library %s", uri.ToCString()); + } + return library; + } + case kClass: { + const Library& library = Library::CheckedHandle(Z, ReadObject()); + const String& class_name = String::CheckedHandle(Z, ReadObject()); + if (class_name.ptr() == Symbols::Empty().ptr()) { + NoSafepointScope no_safepoint_scope(thread_); + ClassPtr cls = library.toplevel_class(); + if (cls == Class::null()) { + FATAL("Unable to find toplevel class %s", library.ToCString()); + } + return cls; + } + ClassPtr cls = library.LookupClassAllowPrivate(class_name); + if (cls == Class::null()) { + FATAL("Unable to find class %s in %s", class_name.ToCString(), + library.ToCString()); + } + return cls; + } + case kMember: { + const Class& cls = Class::CheckedHandle(Z, ReadObject()); + String& name = String::CheckedHandle(Z, ReadObject()); + if ((flags & kFlagIsField) != 0) { + FieldPtr field = cls.LookupField(name); + if (field == Field::null()) { + FATAL("Unable to find field %s in %s", name.ToCString(), + cls.ToCString()); + } + return field; + } else { + if ((flags & kFlagIsConstructor) != 0) { + name = ConstructorName(cls, name); + } + ASSERT(!name.IsNull() && name.IsSymbol()); + if (name.ptr() == scoped_function_name_.ptr() && + cls.ptr() == scoped_function_class_.ptr()) { + return scoped_function_.ptr(); + } + FunctionPtr function = Function::null(); + if ((flags & kFlagIsConstructor) != 0) { + if (cls.EnsureIsAllocateFinalized(thread_) == Error::null()) { + function = Resolver::ResolveFunction(Z, cls, name); + } + } else { + if (cls.EnsureIsFinalized(thread_) == Error::null()) { + function = Resolver::ResolveFunction(Z, cls, name); + } + } + if (function == Function::null()) { + // When requesting a getter, also return method extractors. + if (Field::IsGetterName(name)) { + String& method_name = + String::Handle(Z, Field::NameFromGetter(name)); + function = Resolver::ResolveFunction(Z, cls, method_name); + if (function != Function::null()) { + function = Function::Handle(Z, function).GetMethodExtractor(name); + if (function != Function::null()) { + return function; + } + } + } + FATAL("Unable to find function %s in %s", name.ToCString(), + cls.ToCString()); + } + return function; + } + } + case kClosure: { + ReadObject(); // Skip enclosing member. + const intptr_t closure_index = reader_.ReadUInt(); + return closures_->At(closure_index); + } + case kName: { + if ((flags & kFlagIsPublic) == 0) { + const Library& library = Library::CheckedHandle(Z, ReadObject()); + ASSERT(!library.IsNull()); + auto& name = String::Handle(Z, ReadString(/* is_canonical = */ false)); + name = library.PrivateName(name); + return name.ptr(); + } + return ReadString(); + } + case kTypeArguments: { + return ReadTypeArguments(); + } + case kConstObject: { + const intptr_t tag = flags / kFlagBit0; + return ReadConstObject(tag); + } + case kArgDesc: { + const intptr_t num_arguments = reader_.ReadUInt(); + const intptr_t num_type_args = + ((flags & kFlagHasTypeArgs) != 0) ? reader_.ReadUInt() : 0; + if ((flags & kFlagHasNamedArgs) == 0) { + return ArgumentsDescriptor::NewBoxed(num_type_args, num_arguments); + } else { + const intptr_t num_arg_names = reader_.ReadListLength(); + const Array& array = Array::Handle(Z, Array::New(num_arg_names)); + String& name = String::Handle(Z); + for (intptr_t i = 0; i < num_arg_names; ++i) { + name ^= ReadObject(); + array.SetAt(i, name); + } + return ArgumentsDescriptor::NewBoxed(num_type_args, num_arguments, + array); + } + } + case kScript: { + const String& uri = String::CheckedHandle(Z, ReadObject()); + RELEASE_ASSERT((flags & kFlagHasSourceFile) == 0); + return Script::New(uri, Object::null_string()); + } + case kType: { + const intptr_t tag = (flags & kTagMask) / kFlagBit0; + const Nullability nullability = ((flags & kFlagIsNullable) != 0) + ? Nullability::kNullable + : Nullability::kNonNullable; + return ReadType(tag, nullability); + } + default: + UNREACHABLE(); + } + + return Object::null(); +} + +ObjectPtr BytecodeReaderHelper::ReadConstObject(intptr_t tag) { + // Must be in sync with enum ConstTag in + // pkg/dart2bytecode/lib/object_table.dart. + enum ConstTag { + kInvalid, + kInstance, + kInt, + kDouble, + kList, + kTearOff, + kBool, + kSymbol, + kTearOffInstantiation, + kString, + kMap, + kSet, + }; + + switch (tag) { + case kInvalid: + UNREACHABLE(); + break; + case kInstance: { + const Type& type = Type::CheckedHandle(Z, ReadObject()); + const Class& cls = Class::Handle(Z, type.type_class()); + const Instance& obj = Instance::Handle(Z, Instance::New(cls, Heap::kOld)); + if (type.arguments() != TypeArguments::null()) { + const TypeArguments& type_args = + TypeArguments::Handle(Z, type.arguments()); + obj.SetTypeArguments(type_args); + } + const intptr_t num_fields = reader_.ReadUInt(); + Field& field = Field::Handle(Z); + Object& value = Object::Handle(Z); + for (intptr_t i = 0; i < num_fields; ++i) { + field ^= ReadObject(); + value = ReadObject(); + obj.SetField(field, value); + } + return Canonicalize(obj); + } + case kInt: { + const int64_t value = reader_.ReadSLEB128AsInt64(); + if (Smi::IsValid(value)) { + return Smi::New(static_cast(value)); + } + const Integer& obj = Integer::Handle(Z, Integer::New(value, Heap::kOld)); + return Canonicalize(obj); + } + case kDouble: { + const int64_t bits = reader_.ReadSLEB128AsInt64(); + double value = bit_cast(bits); + const Double& obj = Double::Handle(Z, Double::New(value, Heap::kOld)); + return Canonicalize(obj); + } + case kList: { + const AbstractType& elem_type = + AbstractType::CheckedHandle(Z, ReadObject()); + const intptr_t length = reader_.ReadUInt(); + const Array& array = Array::Handle(Z, Array::New(length, elem_type)); + Object& value = Object::Handle(Z); + for (intptr_t i = 0; i < length; ++i) { + value = ReadObject(); + array.SetAt(i, value); + } + array.MakeImmutable(); + return Canonicalize(array); + } + case kTearOff: { + Object& obj = Object::Handle(Z, ReadObject()); + ASSERT(obj.IsFunction()); + obj = Function::Cast(obj).ImplicitClosureFunction(); + ASSERT(obj.IsFunction()); + obj = Function::Cast(obj).ImplicitStaticClosure(); + ASSERT(obj.IsInstance()); + return Canonicalize(Instance::Cast(obj)); + } + case kBool: { + bool is_true = reader_.ReadByte() != 0; + return is_true ? Bool::True().ptr() : Bool::False().ptr(); + } + case kSymbol: { + const String& name = String::CheckedHandle(Z, ReadObject()); + ASSERT(name.IsSymbol()); + const Library& library = Library::Handle(Z, Library::InternalLibrary()); + ASSERT(!library.IsNull()); + const Class& cls = + Class::Handle(Z, library.LookupClass(Symbols::Symbol())); + ASSERT(!cls.IsNull()); + const Field& field = Field::Handle( + Z, cls.LookupInstanceFieldAllowPrivate(Symbols::_name())); + ASSERT(!field.IsNull()); + const Instance& obj = Instance::Handle(Z, Instance::New(cls, Heap::kOld)); + obj.SetField(field, name); + return Canonicalize(obj); + } + case kTearOffInstantiation: { + Closure& closure = Closure::CheckedHandle(Z, ReadObject()); + const TypeArguments& type_args = + TypeArguments::CheckedHandle(Z, ReadObject()); + closure = Closure::New( + TypeArguments::Handle(Z, closure.instantiator_type_arguments()), + TypeArguments::Handle(Z, closure.function_type_arguments()), + type_args, Function::Handle(Z, closure.function()), + Object::Handle(Z, closure.RawContext()), Heap::kOld); + return Canonicalize(closure); + } + case kString: + return ReadString(); + case kMap: { + const auto& map_type = Type::CheckedHandle(Z, ReadObject()); + const intptr_t used_data = reader_.ReadUInt(); + + const auto& map_class = + Class::Handle(Z, IG->object_store()->const_map_impl_class()); + ASSERT(!map_class.IsNull()); + ASSERT(map_class.is_finalized()); + + auto& type_arguments = TypeArguments::Handle(Z, map_type.arguments()); + type_arguments = + map_class.GetInstanceTypeArguments(thread_, type_arguments); + + const auto& map = Map::Handle(Z, ConstMap::NewUninitialized(Heap::kOld)); + ASSERT_EQUAL(map.GetClassId(), kConstMapCid); + map.SetTypeArguments(type_arguments); + map.set_used_data(used_data); + + const auto& data = Array::Handle(Z, Array::New(used_data)); + map.set_data(data); + map.set_deleted_keys(0); + map.ComputeAndSetHashMask(); + + Object& value = Object::Handle(Z); + for (intptr_t i = 0; i < used_data; ++i) { + value = ReadObject(); + data.SetAt(i, value); + } + return Canonicalize(map); + } + case kSet: { + const AbstractType& elem_type = + AbstractType::CheckedHandle(Z, ReadObject()); + + const auto& set_class = + Class::Handle(Z, IG->object_store()->const_set_impl_class()); + ASSERT(!set_class.IsNull()); + ASSERT(set_class.is_finalized()); + + auto& type_arguments = + TypeArguments::Handle(Z, TypeArguments::New(1, Heap::kOld)); + type_arguments.SetTypeAt(0, elem_type); + type_arguments = + set_class.GetInstanceTypeArguments(thread_, type_arguments); + + const auto& set = Set::Handle(Z, ConstSet::NewUninitialized(Heap::kOld)); + ASSERT_EQUAL(set.GetClassId(), kConstSetCid); + set.SetTypeArguments(type_arguments); + + const intptr_t length = reader_.ReadUInt(); + set.set_used_data(length); + + const auto& data = Array::Handle(Z, Array::New(length)); + set.set_data(data); + set.set_deleted_keys(0); + set.ComputeAndSetHashMask(); + + Object& value = Object::Handle(Z); + for (intptr_t i = 0; i < length; ++i) { + value = ReadObject(); + data.SetAt(i, value); + } + return Canonicalize(set); + } + default: + UNREACHABLE(); + } + return Object::null(); +} + +ObjectPtr BytecodeReaderHelper::ReadType(intptr_t tag, + Nullability nullability) { + // Must be in sync with enum TypeTag in + // pkg/dart2bytecode/lib/object_table.dart. + enum TypeTag { + kInvalid, + kDynamic, + kVoid, + kSimpleType, + kTypeParameter, + kGenericType, + kFunctionType, + kRecordType, + kNull, + kNever, + }; + + // FunctionType flags, must be in sync with _FunctionTypeHandle constants in + // pkg/dart2bytecode/lib/object_table.dart. + const int kFlagHasOptionalPositionalParams = 1 << 0; + const int kFlagHasOptionalNamedParams = 1 << 1; + const int kFlagHasTypeParams = 1 << 2; + + switch (tag) { + case kInvalid: + UNREACHABLE(); + break; + case kDynamic: + return Type::DynamicType(); + case kVoid: + return Type::VoidType(); + case kNull: + return Type::NullType(); + case kNever: + return Type::Handle(Z, Type::NeverType()) + .ToNullability(nullability, Heap::kOld); + case kSimpleType: { + const Class& cls = Class::CheckedHandle(Z, ReadObject()); + if (!cls.is_declaration_loaded()) { + LoadReferencedClass(cls); + } + const Type& type = Type::Handle(Z, cls.DeclarationType()); + return type.ToNullability(nullability, Heap::kOld); + } + case kTypeParameter: { + Object& parent = Object::Handle(Z, ReadObject()); + const intptr_t index_in_parent = reader_.ReadUInt(); + auto& type = TypeParameter::Handle(Z); + if (parent.IsClass()) { + type = + Class::Cast(parent).TypeParameterAt(index_in_parent, nullability); + } else if (parent.IsFunction()) { + if (Function::Cast(parent).IsFactory()) { + // For factory constructors VM uses type parameters of a class + // instead of constructor's type parameters. + parent = Function::Cast(parent).Owner(); + type = + Class::Cast(parent).TypeParameterAt(index_in_parent, nullability); + } else { + type = Function::Cast(parent).TypeParameterAt(index_in_parent, + nullability); + } + } else if (parent.IsNull()) { + ASSERT(!enclosing_function_types_.is_empty()); + for (intptr_t i = enclosing_function_types_.length() - 1; i >= 0; --i) { + parent = enclosing_function_types_[i]->ptr(); + ASSERT(index_in_parent < + FunctionType::Cast(parent).NumTypeArguments()); + if (index_in_parent >= + FunctionType::Cast(parent).NumParentTypeArguments()) { + break; + } + } + type = FunctionType::Cast(parent).TypeParameterAt( + index_in_parent - + FunctionType::Cast(parent).NumParentTypeArguments(), + nullability); + } else { + UNREACHABLE(); + } + return ClassFinalizer::FinalizeType(type, ClassFinalizer::kCanonicalize); + } + case kGenericType: { + const Class& cls = Class::CheckedHandle(Z, ReadObject()); + if (!cls.is_declaration_loaded()) { + LoadReferencedClass(cls); + } + const TypeArguments& type_arguments = + TypeArguments::CheckedHandle(Z, ReadObject()); + const Type& type = + Type::Handle(Z, Type::New(cls, type_arguments, nullability)); + type.SetIsFinalized(); + return type.Canonicalize(thread_); + } + case kFunctionType: { + const intptr_t flags = reader_.ReadUInt(); + const intptr_t num_parent_type_args = + enclosing_function_types_.is_empty() + ? 0 + : enclosing_function_types_.Last()->NumTypeArguments(); + auto& signature_type = FunctionType::Handle( + Z, FunctionType::New(num_parent_type_args, nullability)); + // TODO(alexmarkov): skip type finalization + return ReadFunctionSignature( + signature_type, (flags & kFlagHasOptionalPositionalParams) != 0, + (flags & kFlagHasOptionalNamedParams) != 0, + (flags & kFlagHasTypeParams) != 0, + /* has_positional_param_names = */ false, + /* has_parameter_flags */ false); + } + case kRecordType: + UNIMPLEMENTED(); + default: + UNREACHABLE(); + } + return Object::null(); +} + +StringPtr BytecodeReaderHelper::ReadString(bool is_canonical) { + const int kFlagTwoByteString = 1; + const int kHeaderFields = 2; + const int kUInt32Size = 4; + + uint32_t ref = reader_.ReadUInt(); + const bool isOneByteString = (ref & kFlagTwoByteString) == 0; + intptr_t index = ref >> 1; + + if (!isOneByteString) { + const uint32_t num_one_byte_strings = + reader_.ReadUInt32At(bytecode_component_->GetStringsHeaderOffset()); + index += num_one_byte_strings; + } + + AlternativeReadingScope alt(&reader_, + bytecode_component_->GetStringsHeaderOffset() + + (kHeaderFields + index - 1) * kUInt32Size); + intptr_t start_offs = reader_.ReadUInt32(); + intptr_t end_offs = reader_.ReadUInt32(); + if (index == 0) { + // For the 0-th string we read a header field instead of end offset of + // the previous string. + start_offs = 0; + } + + // Bytecode strings reside in ExternalTypedData which is not movable by GC, + // so it is OK to take a direct pointer to string characters even if + // symbol allocation triggers GC. + const uint8_t* data = reader_.BufferAt( + bytecode_component_->GetStringsContentsOffset() + start_offs); + + if (is_canonical) { + if (isOneByteString) { + return Symbols::FromLatin1(thread_, data, end_offs - start_offs); + } else { + return Symbols::FromUTF16(thread_, + reinterpret_cast(data), + (end_offs - start_offs) >> 1); + } + } else { + if (isOneByteString) { + return String::FromLatin1(data, end_offs - start_offs, Heap::kOld); + } else { + return String::FromUTF16(reinterpret_cast(data), + (end_offs - start_offs) >> 1, Heap::kOld); + } + } +} + +TypeArgumentsPtr BytecodeReaderHelper::ReadTypeArguments() { + const intptr_t length = reader_.ReadUInt(); + TypeArguments& type_arguments = + TypeArguments::ZoneHandle(Z, TypeArguments::New(length)); + AbstractType& type = AbstractType::Handle(Z); + for (intptr_t i = 0; i < length; ++i) { + type ^= ReadObject(); + type_arguments.SetTypeAt(i, type); + } + return type_arguments.Canonicalize(thread_); +} + +void BytecodeReaderHelper::ReadMembers(const Class& cls, bool discard_fields) { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + ASSERT(cls.is_type_finalized()); + ASSERT(!cls.is_loaded()); + + const intptr_t num_functions = reader_.ReadUInt(); + functions_ = &Array::Handle(Z, Array::New(num_functions, Heap::kOld)); + function_index_ = 0; + + ReadFieldDeclarations(cls, discard_fields); + ReadFunctionDeclarations(cls); + + ASSERT(!cls.is_loaded()); + cls.set_is_loaded(true); +} + +void BytecodeReaderHelper::ReadFieldDeclarations(const Class& cls, + bool discard_fields) { + // Field flags, must be in sync with FieldDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + const int kHasNontrivialInitializerFlag = 1 << 0; + const int kHasGetterFlag = 1 << 1; + const int kHasSetterFlag = 1 << 2; + const int kIsReflectableFlag = 1 << 3; + const int kIsStaticFlag = 1 << 4; + const int kIsConstFlag = 1 << 5; + const int kIsFinalFlag = 1 << 6; + const int kIsCovariantFlag = 1 << 7; + const int kIsGenericCovariantImplFlag = 1 << 8; + const int kHasSourcePositionsFlag = 1 << 9; + const int kHasAnnotationsFlag = 1 << 10; + const int kHasPragmaFlag = 1 << 11; + const int kHasCustomScriptFlag = 1 << 12; + const int kHasInitializerCodeFlag = 1 << 13; + const int kIsLateFlag = 1 << 14; + const int kIsExtensionMemberFlag = 1 << 15; + const int kHasInitializerFlag = 1 << 16; + + const int num_fields = reader_.ReadListLength(); + if ((num_fields == 0) && !cls.is_enum_class()) { + return; + } + const Array& fields = Array::Handle( + Z, Array::New(num_fields + (cls.is_enum_class() ? 1 : 0), Heap::kOld)); + String& name = String::Handle(Z); + Object& script_class = Object::Handle(Z); + AbstractType& type = AbstractType::Handle(Z); + Field& field = Field::Handle(Z); + Object& value = Object::Handle(Z); + Function& function = Function::Handle(Z); + + for (intptr_t i = 0; i < num_fields; ++i) { + intptr_t flags = reader_.ReadUInt(); + + const bool is_static = (flags & kIsStaticFlag) != 0; + const bool is_final = (flags & kIsFinalFlag) != 0; + const bool is_const = (flags & kIsConstFlag) != 0; + const bool is_late = (flags & kIsLateFlag) != 0; + const bool has_nontrivial_initializer = + (flags & kHasNontrivialInitializerFlag) != 0; + const bool has_pragma = (flags & kHasPragmaFlag) != 0; + const bool is_extension_member = (flags & kIsExtensionMemberFlag) != 0; + const bool has_initializer = (flags & kHasInitializerFlag) != 0; + + name ^= ReadObject(); + type ^= ReadObject(); + + if ((flags & kHasCustomScriptFlag) != 0) { + Script& script = Script::CheckedHandle(Z, ReadObject()); + script_class = GetPatchClass(cls, script); + } else { + script_class = cls.ptr(); + } + + TokenPosition position = TokenPosition::kNoSource; + TokenPosition end_position = TokenPosition::kNoSource; + if ((flags & kHasSourcePositionsFlag) != 0) { + position = reader_.ReadPosition(); + end_position = reader_.ReadPosition(); + } + + field = Field::New(name, is_static, is_final, is_const, + (flags & kIsReflectableFlag) != 0, is_late, script_class, + type, position, end_position); + + field.set_has_pragma(has_pragma); + field.set_is_covariant((flags & kIsCovariantFlag) != 0); + field.set_is_generic_covariant_impl((flags & kIsGenericCovariantImplFlag) != + 0); + field.set_has_nontrivial_initializer(has_nontrivial_initializer); + field.set_is_extension_member(is_extension_member); + field.set_has_initializer(has_initializer); + + if (!has_nontrivial_initializer) { + value = ReadObject(); + if (is_static) { + if (field.is_late() && !has_initializer) { + value = Object::sentinel().ptr(); + } + } else { + // Null-initialized instance fields are tracked separately for each + // constructor (see handling of kHasNullableFieldsFlag). + if (!value.IsNull()) { + field.RecordStore(value); + } + } + } + + if ((flags & kHasInitializerCodeFlag) != 0) { + const intptr_t code_offset = reader_.ReadUInt(); + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + loader->SetOffset(field, + code_offset + bytecode_component_->GetCodesOffset()); + if (is_static) { + value = Object::sentinel().ptr(); + } + } + + if ((flags & kHasGetterFlag) != 0) { + name ^= ReadObject(); + const auto& signature = FunctionType::Handle(Z, FunctionType::New()); + function = + Function::New(signature, name, + is_static ? UntaggedFunction::kImplicitStaticGetter + : UntaggedFunction::kImplicitGetter, + is_static, is_const, + false, // is_abstract + false, // is_external + false, // is_native + script_class, position); + NOT_IN_PRECOMPILED(function.set_end_token_pos(end_position)); + signature.set_result_type(type); + function.set_is_debuggable(false); + function.set_accessor_field(field); + function.set_is_extension_member(is_extension_member); + SetupFieldAccessorFunction(cls, function, type); + if (is_const && has_nontrivial_initializer) { + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + loader->SetOffset(function, loader->GetOffset(field)); + } else { + if (is_static) { + function.AttachBytecode(Object::implicit_static_getter_bytecode()); + } else { + function.AttachBytecode(Object::implicit_getter_bytecode()); + } + } + functions_->SetAt(function_index_++, function); + } + + if ((flags & kHasSetterFlag) != 0) { + ASSERT(is_late || ((!is_static) && (!is_final))); + ASSERT(!is_const); + name ^= ReadObject(); + const auto& signature = FunctionType::Handle(Z, FunctionType::New()); + function = Function::New(signature, name, + UntaggedFunction::kImplicitSetter, is_static, + false, // is_const + false, // is_abstract + false, // is_external + false, // is_native + script_class, position); + NOT_IN_PRECOMPILED(function.set_end_token_pos(end_position)); + signature.set_result_type(Object::void_type()); + function.set_is_debuggable(false); + function.set_accessor_field(field); + function.set_is_extension_member(is_extension_member); + SetupFieldAccessorFunction(cls, function, type); + function.AttachBytecode(Object::implicit_setter_bytecode()); + functions_->SetAt(function_index_++, function); + } + + if ((flags & kHasAnnotationsFlag) != 0) { + reader_.ReadUInt(); // Skip annotations offset. + } + + if (field.is_static()) { + IG->RegisterStaticField(field, value); + } + + fields.SetAt(i, field); + } + + if (cls.is_enum_class()) { + // Add static field 'const _deleted_enum_sentinel'. + field = Field::New(Symbols::_DeletedEnumSentinel(), + /* is_static = */ true, + /* is_final = */ true, + /* is_const = */ true, + /* is_reflectable = */ false, + /* is_late = */ false, cls, Object::dynamic_type(), + TokenPosition::kNoSource, TokenPosition::kNoSource); + + fields.SetAt(num_fields, field); + } + + if (!discard_fields) { + cls.SetFields(fields); + } + + if (cls.IsTopLevel()) { + const Library& library = Library::Handle(Z, cls.library()); + for (intptr_t i = 0, n = fields.Length(); i < n; ++i) { + field ^= fields.At(i); + name = field.name(); + library.AddObject(field, name); + } + } +} + +// TODO(alexmarkov): unify with +// TranslationHelper::SetupFieldAccessorFunction. +void BytecodeReaderHelper::SetupFieldAccessorFunction( + const Class& klass, + const Function& function, + const AbstractType& field_type) { + bool is_setter = function.IsImplicitSetterFunction(); + bool is_method = !function.IsStaticFunction(); + intptr_t parameter_count = (is_method ? 1 : 0) + (is_setter ? 1 : 0); + + const FunctionType& signature = FunctionType::Handle(Z, function.signature()); + signature.SetNumOptionalParameters(0, false); + signature.set_num_fixed_parameters(parameter_count); + if (parameter_count > 0) { + signature.set_parameter_types( + Array::Handle(Z, Array::New(parameter_count, Heap::kOld))); + } + NOT_IN_PRECOMPILED(function.CreateNameArray()); + + intptr_t pos = 0; + if (is_method) { + signature.SetParameterTypeAt( + pos, AbstractType::Handle(Z, klass.DeclarationType())); + NOT_IN_PRECOMPILED(function.SetParameterNameAt(pos, Symbols::This())); + pos++; + } + if (is_setter) { + signature.SetParameterTypeAt(pos, field_type); + NOT_IN_PRECOMPILED(function.SetParameterNameAt(pos, Symbols::Value())); + pos++; + } +} + +PatchClassPtr BytecodeReaderHelper::GetPatchClass(const Class& cls, + const Script& script) { + if (patch_class_ != nullptr && patch_class_->wrapped_class() == cls.ptr() && + patch_class_->script() == script.ptr()) { + return patch_class_->ptr(); + } + if (patch_class_ == nullptr) { + patch_class_ = &PatchClass::Handle(Z); + } + *patch_class_ = PatchClass::New(cls, KernelProgramInfo::Handle(Z), script); + return patch_class_->ptr(); +} + +InstancePtr BytecodeReaderHelper::Canonicalize(const Instance& instance) { + if (instance.IsNull()) return instance.ptr(); + return instance.Canonicalize(thread_); +} + +void BytecodeReaderHelper::ReadFunctionDeclarations(const Class& cls) { + // Function flags, must be in sync with FunctionDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + const int kIsConstructorFlag = 1 << 0; + const int kIsGetterFlag = 1 << 1; + const int kIsSetterFlag = 1 << 2; + const int kIsFactoryFlag = 1 << 3; + const int kIsStaticFlag = 1 << 4; + const int kIsAbstractFlag = 1 << 5; + const int kIsConstFlag = 1 << 6; + const int kHasOptionalPositionalParamsFlag = 1 << 7; + const int kHasOptionalNamedParamsFlag = 1 << 8; + const int kHasTypeParamsFlag = 1 << 9; + const int kIsReflectableFlag = 1 << 10; + const int kIsDebuggableFlag = 1 << 11; + const int kIsAsyncFlag = 1 << 12; + const int kIsAsyncStarFlag = 1 << 13; + const int kIsSyncStarFlag = 1 << 14; + // const int kIsForwardingStubFlag = 1 << 15; + const int kIsNoSuchMethodForwarderFlag = 1 << 16; + const int kIsNativeFlag = 1 << 17; + const int kIsExternalFlag = 1 << 18; + const int kHasSourcePositionsFlag = 1 << 19; + const int kHasAnnotationsFlag = 1 << 20; + const int kHasPragmaFlag = 1 << 21; + const int kHasCustomScriptFlag = 1 << 22; + const int kIsExtensionMemberFlag = 1 << 23; + const int kHasParameterFlagsFlag = 1 << 24; + + const intptr_t num_functions = reader_.ReadListLength(); + ASSERT(function_index_ + num_functions == functions_->Length()); + + if (function_index_ + num_functions == 0) { + return; + } + + String& name = String::Handle(Z); + Object& script_class = Object::Handle(Z); + FunctionType& signature = FunctionType::Handle(Z); + Function& function = Function::Handle(Z); + Array& parameter_types = Array::Handle(Z); + AbstractType& type = AbstractType::Handle(Z); + + name = cls.ScrubbedName(); + + for (intptr_t i = 0; i < num_functions; ++i) { + intptr_t flags = reader_.ReadUInt(); + + const bool is_static = (flags & kIsStaticFlag) != 0; + const bool is_factory = (flags & kIsFactoryFlag) != 0; + const bool is_native = (flags & kIsNativeFlag) != 0; + const bool has_pragma = (flags & kHasPragmaFlag) != 0; + const bool is_extension_member = (flags & kIsExtensionMemberFlag) != 0; + + name ^= ReadObject(); + + if ((flags & kHasCustomScriptFlag) != 0) { + Script& script = Script::CheckedHandle(Z, ReadObject()); + script_class = GetPatchClass(cls, script); + } else { + script_class = cls.ptr(); + } + + TokenPosition position = TokenPosition::kNoSource; + TokenPosition end_position = TokenPosition::kNoSource; + if ((flags & kHasSourcePositionsFlag) != 0) { + position = reader_.ReadPosition(); + end_position = reader_.ReadPosition(); + } + + UntaggedFunction::Kind kind = UntaggedFunction::kRegularFunction; + if ((flags & kIsGetterFlag) != 0) { + kind = UntaggedFunction::kGetterFunction; + } else if ((flags & kIsSetterFlag) != 0) { + kind = UntaggedFunction::kSetterFunction; + } else if ((flags & (kIsConstructorFlag | kIsFactoryFlag)) != 0) { + kind = UntaggedFunction::kConstructor; + name = ConstructorName(cls, name); + } + + signature = FunctionType::New(); + function = Function::New( + signature, name, kind, is_static, (flags & kIsConstFlag) != 0, + (flags & kIsAbstractFlag) != 0, (flags & kIsExternalFlag) != 0, + is_native, script_class, position); + + // Declare function scope as types (type parameters) in function + // signature may back-reference to the function being declared. + // At this moment, owner class is not fully loaded yet and it won't be + // able to serve function lookup requests. + FunctionScope function_scope(this, function, name, cls); + + function.set_has_pragma(has_pragma); + NOT_IN_PRECOMPILED(function.set_end_token_pos(end_position)); + function.set_is_synthetic((flags & kIsNoSuchMethodForwarderFlag) != 0); + function.set_is_reflectable((flags & kIsReflectableFlag) != 0); + function.set_is_debuggable((flags & kIsDebuggableFlag) != 0); + function.set_is_extension_member(is_extension_member); + + if ((flags & kIsSyncStarFlag) != 0) { + function.set_modifier(UntaggedFunction::kSyncGen); + function.set_is_inlinable(false); + } else if ((flags & kIsAsyncFlag) != 0) { + function.set_modifier(UntaggedFunction::kAsync); + function.set_is_inlinable(false); + } else if ((flags & kIsAsyncStarFlag) != 0) { + function.set_modifier(UntaggedFunction::kAsyncGen); + function.set_is_inlinable(false); + } + + if ((flags & kHasTypeParamsFlag) != 0) { + ReadTypeParametersDeclaration(Class::Handle(Z), signature); + } + + const intptr_t num_implicit_params = (!is_static || is_factory) ? 1 : 0; + const intptr_t num_params = num_implicit_params + reader_.ReadUInt(); + const bool has_optional_named_params = + ((flags & kHasOptionalNamedParamsFlag) != 0); + + intptr_t num_required_params = num_params; + if ((flags & (kHasOptionalPositionalParamsFlag | + kHasOptionalNamedParamsFlag)) != 0) { + num_required_params = num_implicit_params + reader_.ReadUInt(); + } + + signature.set_num_fixed_parameters(num_required_params); + signature.SetNumOptionalParameters(num_params - num_required_params, + !has_optional_named_params); + + if (num_params > 0) { + parameter_types = Array::New(num_params, Heap::kOld); + signature.set_parameter_types(parameter_types); + signature.CreateNameArrayIncludingFlags(Heap::kOld); + NOT_IN_PRECOMPILED(function.CreateNameArray()); + } + + intptr_t param_index = 0; + if (!is_static) { + type = cls.DeclarationType(); + signature.SetParameterTypeAt(param_index, type); + NOT_IN_PRECOMPILED( + function.SetParameterNameAt(param_index, Symbols::This())); + ++param_index; + } else if (is_factory) { + signature.SetParameterTypeAt(param_index, AbstractType::dynamic_type()); + NOT_IN_PRECOMPILED(function.SetParameterNameAt( + param_index, Symbols::TypeArgumentsParameter())); + ++param_index; + } + + for (; param_index < num_params; ++param_index) { + name ^= ReadObject(); + if (has_optional_named_params && (param_index >= num_required_params)) { + signature.SetParameterNameAt(param_index, name); + } else { + NOT_IN_PRECOMPILED(function.SetParameterNameAt(param_index, name)); + } + type ^= ReadObject(); + signature.SetParameterTypeAt(param_index, type); + } + + if ((flags & kHasParameterFlagsFlag) != 0) { + const intptr_t length = reader_.ReadUInt(); + const intptr_t offset = function.NumImplicitParameters(); + for (intptr_t i = 0; i < length; i++) { + const intptr_t param_flags = reader_.ReadUInt(); + if ((param_flags & Parameter::kIsRequiredFlag) != 0) { + RELEASE_ASSERT(function.HasOptionalNamedParameters()); + RELEASE_ASSERT(i + offset >= function.num_fixed_parameters()); + signature.SetIsRequiredAt(i + offset); + } + } + } + + type ^= ReadObject(); + signature.set_result_type(type); + + if (is_native) { + name ^= ReadObject(); + function.set_native_name(name); + } + + if ((flags & kIsAbstractFlag) == 0) { + const intptr_t code_offset = reader_.ReadUInt(); + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + loader->SetOffset(function, + code_offset + bytecode_component_->GetCodesOffset()); + } + + if ((flags & kHasAnnotationsFlag) != 0) { + reader_.ReadUInt(); // Skip annotations offset. + } + + functions_->SetAt(function_index_++, function); + } + + { + Thread* thread = Thread::Current(); + SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock()); + cls.SetFunctions(*functions_); + } + + if (cls.IsTopLevel()) { + const Library& library = Library::Handle(Z, cls.library()); + for (intptr_t i = 0, n = functions_->Length(); i < n; ++i) { + function ^= functions_->At(i); + name = function.name(); + library.AddObject(function, name); + } + } + + functions_ = nullptr; +} + +void BytecodeReaderHelper::LoadReferencedClass(const Class& cls) { + ASSERT(!cls.is_declaration_loaded()); + + if (!cls.is_declared_in_bytecode()) { + cls.EnsureDeclarationLoaded(); + return; + } + + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + + AlternativeReadingScope alt(&reader_, loader->GetOffset(cls)); + ReadClassDeclaration(cls); +} + +void BytecodeReaderHelper::ReadClassDeclaration(const Class& cls) { + // Class flags, must be in sync with ClassDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + const int kIsAbstractFlag = 1 << 0; + const int kIsEnumFlag = 1 << 1; + const int kHasTypeParamsFlag = 1 << 2; + const int kHasTypeArgumentsFlag = 1 << 3; + const int kIsTransformedMixinApplicationFlag = 1 << 4; + const int kHasSourcePositionsFlag = 1 << 5; + const int kHasAnnotationsFlag = 1 << 6; + const int kHasPragmaFlag = 1 << 7; + + // Class is allocated when reading library declaration in + // BytecodeReaderHelper::ReadLibraryDeclaration. + // Its cid is set in Class::New / IsolateGroup::RegisterClass / + // ClassTable::Register, unless it was loaded for expression evaluation. + ASSERT(cls.is_declared_in_bytecode()); + ASSERT(!cls.is_declaration_loaded()); + + const intptr_t flags = reader_.ReadUInt(); + const bool has_pragma = (flags & kHasPragmaFlag) != 0; + + // Set early to enable access to type_parameters(). + // TODO(alexmarkov): revise early stamping of native wrapper classes + // as loaded. + if (!cls.is_declaration_loaded()) { + cls.set_is_declaration_loaded(); + } + + const auto& script = Script::CheckedHandle(Z, ReadObject()); + cls.set_script(script); + + TokenPosition position = TokenPosition::kNoSource; + TokenPosition end_position = TokenPosition::kNoSource; + if ((flags & kHasSourcePositionsFlag) != 0) { + position = reader_.ReadPosition(); + end_position = reader_.ReadPosition(); + NOT_IN_PRECOMPILED(cls.set_token_pos(position)); + NOT_IN_PRECOMPILED(cls.set_end_token_pos(end_position)); + } + + cls.set_has_pragma(has_pragma); + + if ((flags & kIsAbstractFlag) != 0) { + cls.set_is_abstract(); + } + if ((flags & kIsEnumFlag) != 0) { + cls.set_is_enum_class(); + } + if ((flags & kIsTransformedMixinApplicationFlag) != 0) { + cls.set_is_transformed_mixin_application(); + } + + intptr_t num_type_arguments = 0; + if ((flags & kHasTypeArgumentsFlag) != 0) { + num_type_arguments = reader_.ReadUInt(); + } + cls.set_num_type_arguments(num_type_arguments); + + if ((flags & kHasTypeParamsFlag) != 0) { + ReadTypeParametersDeclaration(cls, Object::null_function_type()); + } + + auto& type = AbstractType::CheckedHandle(Z, ReadObject()); + if (!type.IsNull()) { + cls.set_super_type(Type::Cast(type)); + } + + const intptr_t num_interfaces = reader_.ReadUInt(); + if (num_interfaces > 0) { + const auto& interfaces = + Array::Handle(Z, Array::New(num_interfaces, Heap::kOld)); + for (intptr_t i = 0; i < num_interfaces; ++i) { + type ^= ReadObject(); + interfaces.SetAt(i, type); + } + cls.set_interfaces(interfaces); + } + + if ((flags & kHasAnnotationsFlag) != 0) { + reader_.ReadUInt(); // Skip annotations offset. + } + + const intptr_t members_offset = reader_.ReadUInt(); + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + loader->SetOffset(cls, + members_offset + bytecode_component_->GetMembersOffset()); + + if (!cls.is_type_finalized()) { + ClassFinalizer::FinalizeTypesInClass(cls); + } +} + +void BytecodeReaderHelper::ReadLibraryDeclaration( + const Library& library, + bool lookup_classes, + const GrowableObjectArray& pending_classes) { + // Library flags, must be in sync with LibraryDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + // const int kUsesDartMirrorsFlag = 1 << 0; + // const int kUsesDartFfiFlag = 1 << 1; + + ASSERT(!library.Loaded()); + ASSERT(library.toplevel_class() == Object::null()); + + // TODO(alexmarkov): fill in library.used_scripts. + + reader_.ReadUInt(); // Flags. + + auto& name = String::CheckedHandle(Z, ReadObject()); + ASSERT(name.ptr() != + Symbols::Symbol(Symbols::kDartNativeWrappersLibNameId).ptr()); + library.SetName(name); + + const auto& script = Script::CheckedHandle(Z, ReadObject()); + + library.SetLoadInProgress(); + + const intptr_t num_classes = reader_.ReadUInt(); + ASSERT(num_classes > 0); + auto& cls = Class::Handle(Z); + + for (intptr_t i = 0; i < num_classes; ++i) { + name ^= ReadObject(); + const intptr_t class_offset = + bytecode_component_->GetClassesOffset() + reader_.ReadUInt(); + + if (i == 0) { + ASSERT(name.ptr() == Symbols::Empty().ptr()); + cls = Class::New(library, Symbols::TopLevel(), script, + TokenPosition::kNoSource, /*register_class=*/true); + cls.set_is_declared_in_bytecode(true); + library.set_toplevel_class(cls); + } else { + if (lookup_classes) { + cls = library.LookupClassAllowPrivate(name); + } + if (lookup_classes && !cls.IsNull()) { + ASSERT(!cls.is_declaration_loaded()); + cls.set_script(script); + } else { + cls = Class::New(library, name, script, TokenPosition::kNoSource, + /*register_class=*/true); + cls.set_is_declared_in_bytecode(true); + library.AddClass(cls); + } + } + + BytecodeLoader* loader = thread_->bytecode_loader(); + ASSERT(loader != nullptr); + loader->SetOffset(cls, class_offset); + pending_classes.Add(cls); + } + + ASSERT(!library.Loaded()); + library.SetLoaded(); +} + +void BytecodeReaderHelper::ReadLibraryDeclarations(intptr_t num_libraries) { + auto& library = Library::Handle(Z); + auto& uri = String::Handle(Z); + auto& pending_classes = + GrowableObjectArray::Handle(Z, GrowableObjectArray::New()); + + for (intptr_t i = 0; i < num_libraries; ++i) { + uri ^= ReadObject(); + const intptr_t library_offset = + bytecode_component_->GetLibrariesOffset() + reader_.ReadUInt(); + + bool lookup_classes = true; + library = Library::LookupLibrary(thread_, uri); + if (library.IsNull()) { + lookup_classes = false; + library = Library::New(uri); + library.Register(thread_); + } + + if (library.Loaded()) { + continue; + } + + AlternativeReadingScope alt(&reader_, library_offset); + ReadLibraryDeclaration(library, lookup_classes, pending_classes); + } + + auto& cls = Class::Handle(Z); + auto& error = Error::Handle(Z); + auto& members = Array::Handle(Z); + auto& function = Function::Handle(Z); + auto& field = Field::Handle(Z); + for (intptr_t i = 0, n = pending_classes.Length(); i < n; ++i) { + cls ^= pending_classes.At(i); + OS::PrintErr("Pending class %s\n", cls.ToCString()); + error = cls.EnsureIsFinalized(thread_); + if (!error.IsNull()) { + Exceptions::PropagateError(error); + UNREACHABLE(); + } + members = cls.functions(); + for (intptr_t j = 0, m = members.Length(); j < m; ++j) { + function ^= members.At(j); + if (!function.is_abstract() && !function.HasBytecode()) { + OS::PrintErr("ReadCode %s\n", function.ToFullyQualifiedCString()); + ReadCode(function, thread_->bytecode_loader()->GetOffset(function)); + } + } + members = cls.fields(); + for (intptr_t j = 0, m = members.Length(); j < m; ++j) { + field ^= members.At(j); + if ((field.is_static() || field.is_late()) && + field.has_nontrivial_initializer()) { + function = field.EnsureInitializerFunction(); + if (!function.HasBytecode()) { + OS::PrintErr("ReadCode %s\n", function.ToFullyQualifiedCString()); + ReadCode(function, thread_->bytecode_loader()->GetOffset(field)); + } + } + } + } +} + +void BytecodeReaderHelper::ReadParameterCovariance( + const Function& function, + intptr_t code_offset, + BitVector* is_covariant, + BitVector* is_generic_covariant_impl) { + ASSERT(function.is_declared_in_bytecode()); + + const intptr_t num_params = function.NumParameters(); + ASSERT(is_covariant->length() == num_params); + ASSERT(is_generic_covariant_impl->length() == num_params); + + AlternativeReadingScope alt(&reader_, code_offset); + + const intptr_t code_flags = reader_.ReadUInt(); + if ((code_flags & Code::kHasParameterFlagsFlag) != 0) { + const intptr_t num_explicit_params = reader_.ReadUInt(); + ASSERT(num_params == + function.NumImplicitParameters() + num_explicit_params); + + for (intptr_t i = function.NumImplicitParameters(); i < num_params; ++i) { + const intptr_t flags = reader_.ReadUInt(); + + if ((flags & Parameter::kIsCovariantFlag) != 0) { + is_covariant->Add(i); + } + if ((flags & Parameter::kIsGenericCovariantImplFlag) != 0) { + is_generic_covariant_impl->Add(i); + } + } + } +} + +LibraryPtr BytecodeReaderHelper::ReadMain() { + return Library::RawCast(ReadObject()); +} + +TypedDataBasePtr BytecodeComponentData::GetTypedData() const { + return TypedDataBase::RawCast(data_.At(kTypedData)); +} + +intptr_t BytecodeComponentData::GetVersion() const { + return Smi::Value(Smi::RawCast(data_.At(kVersion))); +} + +intptr_t BytecodeComponentData::GetStringsHeaderOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kStringsHeaderOffset))); +} + +intptr_t BytecodeComponentData::GetStringsContentsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kStringsContentsOffset))); +} + +intptr_t BytecodeComponentData::GetObjectOffsetsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kObjectOffsetsOffset))); +} + +intptr_t BytecodeComponentData::GetNumObjects() const { + return Smi::Value(Smi::RawCast(data_.At(kNumObjects))); +} + +intptr_t BytecodeComponentData::GetObjectsContentsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kObjectsContentsOffset))); +} + +intptr_t BytecodeComponentData::GetMainOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kMainOffset))); +} + +intptr_t BytecodeComponentData::GetNumLibraries() const { + return Smi::Value(Smi::RawCast(data_.At(kNumLibraries))); +} + +intptr_t BytecodeComponentData::GetLibraryIndexOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kLibraryIndexOffset))); +} + +intptr_t BytecodeComponentData::GetLibrariesOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kLibrariesOffset))); +} + +intptr_t BytecodeComponentData::GetNumClasses() const { + return Smi::Value(Smi::RawCast(data_.At(kNumClasses))); +} + +intptr_t BytecodeComponentData::GetClassesOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kClassesOffset))); +} + +intptr_t BytecodeComponentData::GetMembersOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kMembersOffset))); +} + +intptr_t BytecodeComponentData::GetNumCodes() const { + return Smi::Value(Smi::RawCast(data_.At(kNumCodes))); +} + +intptr_t BytecodeComponentData::GetCodesOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kCodesOffset))); +} + +intptr_t BytecodeComponentData::GetSourcePositionsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kSourcePositionsOffset))); +} + +intptr_t BytecodeComponentData::GetSourceFilesOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kSourceFilesOffset))); +} + +intptr_t BytecodeComponentData::GetLineStartsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kLineStartsOffset))); +} + +intptr_t BytecodeComponentData::GetLocalVariablesOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kLocalVariablesOffset))); +} + +intptr_t BytecodeComponentData::GetAnnotationsOffset() const { + return Smi::Value(Smi::RawCast(data_.At(kAnnotationsOffset))); +} + +void BytecodeComponentData::SetObject(intptr_t index, const Object& obj) const { + data_.SetAt(kNumFields + index, obj); +} + +ObjectPtr BytecodeComponentData::GetObject(intptr_t index) const { + return data_.At(kNumFields + index); +} + +ArrayPtr BytecodeComponentData::New(Zone* zone, + const TypedDataBase& typed_data, + intptr_t version, + intptr_t num_objects, + intptr_t strings_header_offset, + intptr_t strings_contents_offset, + intptr_t object_offsets_offset, + intptr_t objects_contents_offset, + intptr_t main_offset, + intptr_t num_libraries, + intptr_t library_index_offset, + intptr_t libraries_offset, + intptr_t num_classes, + intptr_t classes_offset, + intptr_t members_offset, + intptr_t num_codes, + intptr_t codes_offset, + intptr_t source_positions_offset, + intptr_t source_files_offset, + intptr_t line_starts_offset, + intptr_t local_variables_offset, + intptr_t annotations_offset, + Heap::Space space) { + const Array& data = + Array::Handle(zone, Array::New(kNumFields + num_objects, space)); + Smi& smi_handle = Smi::Handle(zone); + + data.SetAt(kTypedData, typed_data); + + smi_handle = Smi::New(version); + data.SetAt(kVersion, smi_handle); + + smi_handle = Smi::New(strings_header_offset); + data.SetAt(kStringsHeaderOffset, smi_handle); + + smi_handle = Smi::New(strings_contents_offset); + data.SetAt(kStringsContentsOffset, smi_handle); + + smi_handle = Smi::New(object_offsets_offset); + data.SetAt(kObjectOffsetsOffset, smi_handle); + + smi_handle = Smi::New(num_objects); + data.SetAt(kNumObjects, smi_handle); + + smi_handle = Smi::New(objects_contents_offset); + data.SetAt(kObjectsContentsOffset, smi_handle); + + smi_handle = Smi::New(main_offset); + data.SetAt(kMainOffset, smi_handle); + + smi_handle = Smi::New(num_libraries); + data.SetAt(kNumLibraries, smi_handle); + + smi_handle = Smi::New(library_index_offset); + data.SetAt(kLibraryIndexOffset, smi_handle); + + smi_handle = Smi::New(libraries_offset); + data.SetAt(kLibrariesOffset, smi_handle); + + smi_handle = Smi::New(num_classes); + data.SetAt(kNumClasses, smi_handle); + + smi_handle = Smi::New(classes_offset); + data.SetAt(kClassesOffset, smi_handle); + + smi_handle = Smi::New(members_offset); + data.SetAt(kMembersOffset, smi_handle); + + smi_handle = Smi::New(num_codes); + data.SetAt(kNumCodes, smi_handle); + + smi_handle = Smi::New(codes_offset); + data.SetAt(kCodesOffset, smi_handle); + + smi_handle = Smi::New(source_positions_offset); + data.SetAt(kSourcePositionsOffset, smi_handle); + + smi_handle = Smi::New(source_files_offset); + data.SetAt(kSourceFilesOffset, smi_handle); + + smi_handle = Smi::New(line_starts_offset); + data.SetAt(kLineStartsOffset, smi_handle); + + smi_handle = Smi::New(local_variables_offset); + data.SetAt(kLocalVariablesOffset, smi_handle); + + smi_handle = Smi::New(annotations_offset); + data.SetAt(kAnnotationsOffset, smi_handle); + + return data.ptr(); +} + +void BytecodeReader::LoadClassDeclaration(const Class& cls) { + ASSERT(cls.is_declared_in_bytecode()); + ASSERT(!cls.is_declaration_loaded()); + + Thread* thread = Thread::Current(); + Zone* zone = thread->zone(); + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + + BytecodeLoader* loader = thread->bytecode_loader(); + ASSERT(loader != nullptr); + + BytecodeComponentData bytecode_component( + Array::Handle(zone, loader->bytecode_component_array())); + ASSERT(!bytecode_component.IsNull()); + BytecodeReaderHelper bytecode_reader(thread, &bytecode_component); + + AlternativeReadingScope alt(&bytecode_reader.reader(), + loader->GetOffset(cls)); + bytecode_reader.ReadClassDeclaration(cls); +} + +void BytecodeReader::FinishClassLoading(const Class& cls) { + ASSERT(cls.is_declared_in_bytecode()); + + Thread* thread = Thread::Current(); + Zone* zone = thread->zone(); + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + + BytecodeLoader* loader = thread->bytecode_loader(); + ASSERT(loader != nullptr); + + BytecodeComponentData bytecode_component( + Array::Handle(zone, loader->bytecode_component_array())); + ASSERT(!bytecode_component.IsNull()); + BytecodeReaderHelper bytecode_reader(thread, &bytecode_component); + + AlternativeReadingScope alt(&bytecode_reader.reader(), + loader->GetOffset(cls)); + + // If this is a dart:internal.ClassID class ignore field declarations + // contained in the Kernel file and instead inject our own const + // fields. + const bool discard_fields = cls.InjectCIDFields(); + + bytecode_reader.ReadMembers(cls, discard_fields); +} + +void BytecodeReader::ReadParameterCovariance( + const Function& function, + BitVector* is_covariant, + BitVector* is_generic_covariant_impl) { + ASSERT(function.is_declared_in_bytecode()); + ASSERT(!function.IsClosureFunction()); + + // Method extractors of abstract methods are only used as + // targets of interface calls, so covariance of parameters is irrelevant. + if (function.is_abstract()) { + return; + } + + Thread* thread = Thread::Current(); + Zone* zone = thread->zone(); + + auto& binary = TypedDataBase::Handle(zone); + intptr_t offset = 0; + + const auto& bytecode = Bytecode::Handle(zone, function.GetBytecode()); + if (bytecode.IsNull()) { + BytecodeLoader* loader = thread->bytecode_loader(); + ASSERT(loader != nullptr); + binary = loader->binary(); + offset = loader->GetOffset(function); + } else { + binary = bytecode.binary(); + ASSERT(!binary.IsNull()); + offset = bytecode.code_offset(); + ASSERT(offset > 0); + } + BytecodeReaderHelper bytecode_reader(thread, binary); + bytecode_reader.ReadParameterCovariance(function, offset, is_covariant, + is_generic_covariant_impl); +} + +} // namespace bytecode +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) diff --git a/runtime/vm/bytecode_reader.h b/runtime/vm/bytecode_reader.h new file mode 100644 index 00000000000..6e4835ca2f1 --- /dev/null +++ b/runtime/vm/bytecode_reader.h @@ -0,0 +1,521 @@ +// Copyright (c) 2024, 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_BYTECODE_READER_H_ +#define RUNTIME_VM_BYTECODE_READER_H_ + +#include "vm/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/bit_vector.h" +#include "vm/constants_kbc.h" +#include "vm/hash_table.h" +#include "vm/object.h" + +namespace dart { +namespace bytecode { + +class BytecodeComponentData; + +class BytecodeLoader { + public: + BytecodeLoader(Thread* thread, const TypedDataBase& binary); + ~BytecodeLoader(); + + FunctionPtr LoadBytecode(); + + TypedDataBasePtr binary() const { return binary_.ptr(); } + ArrayPtr bytecode_component_array() const { + return bytecode_component_array_.ptr(); + } + + void SetOffset(const Object& obj, intptr_t offset); + intptr_t GetOffset(const Object& obj); + + private: + Thread* thread_; + const TypedDataBase& binary_; + Array& bytecode_component_array_; + Array& bytecode_offsets_map_; + + DISALLOW_COPY_AND_ASSIGN(BytecodeLoader); +}; + +class Reader : public ValueObject { + public: + explicit Reader(const TypedDataBase& typed_data) : typed_data_(&typed_data) { + Init(); + } + + uint32_t ReadUInt32At(intptr_t offset) const { + ASSERT((size_ >= 4) && (offset >= 0) && (offset <= size_ - 4)); + uint32_t value = + LoadUnaligned(reinterpret_cast(raw_buffer_ + offset)); + return Utils::BigEndianToHost32(value); + } + + uint32_t ReadUInt32() { + uint32_t value = ReadUInt32At(offset_); + offset_ += 4; + return value; + } + + uint32_t ReadUInt() { + ASSERT((size_ >= 1) && (offset_ >= 0) && (offset_ <= size_ - 1)); + + const uint8_t* buffer = raw_buffer_; + uword byte0 = buffer[offset_]; + if ((byte0 & 0x80) == 0) { + // 0... + offset_++; + return byte0; + } else if ((byte0 & 0xc0) == 0x80) { + // 10... + ASSERT((size_ >= 2) && (offset_ >= 0) && (offset_ <= size_ - 2)); + uint32_t value = + ((byte0 & ~static_cast(0x80)) << 8) | (buffer[offset_ + 1]); + offset_ += 2; + return value; + } else { + // 11... + ASSERT((size_ >= 4) && (offset_ >= 0) && (offset_ <= size_ - 4)); + uint32_t value = ((byte0 & ~static_cast(0xc0)) << 24) | + (buffer[offset_ + 1] << 16) | + (buffer[offset_ + 2] << 8) | (buffer[offset_ + 3] << 0); + offset_ += 4; + return value; + } + } + + intptr_t ReadSLEB128() { + ReadStream stream(raw_buffer_, size_, offset_); + const intptr_t result = stream.ReadSLEB128(); + offset_ = stream.Position(); + return result; + } + + int64_t ReadSLEB128AsInt64() { + ReadStream stream(raw_buffer_, size_, offset_); + const int64_t result = stream.ReadSLEB128(); + offset_ = stream.Position(); + return result; + } + + /** + * Read and return a TokenPosition from this reader. + */ + TokenPosition ReadPosition() { + // Position is saved as unsigned, + // but actually ranges from -1 and up (thus the -1) + intptr_t value = ReadUInt() - 1; + TokenPosition result = TokenPosition::Deserialize(value); + return result; + } + + intptr_t ReadListLength() { return ReadUInt(); } + + uint8_t ReadByte() { return raw_buffer_[offset_++]; } + + uint8_t PeekByte() { return raw_buffer_[offset_]; } + + void ReadBytes(uint8_t* buffer, uint8_t size) { + for (int i = 0; i < size; i++) { + buffer[i] = ReadByte(); + } + } + + const TypedDataBase* typed_data() { return typed_data_; } + + intptr_t offset() const { return offset_; } + void set_offset(intptr_t offset) { + ASSERT(offset <= size_); + offset_ = offset; + } + intptr_t size() const { return size_; } + + TypedDataViewPtr ViewFromTo(intptr_t start, intptr_t end) { + return typed_data_->ViewFromTo(start, end, Heap::kOld); + } + + const uint8_t* BufferAt(intptr_t offset) { + ASSERT((offset >= 0) && (offset < size_)); + return &raw_buffer_[offset]; + } + + private: + friend class AlternativeReadingScope; + + void Init() { + ASSERT(typed_data_->IsExternalOrExternalView()); + raw_buffer_ = reinterpret_cast(typed_data_->DataAddr(0)); + size_ = typed_data_->LengthInBytes(); + offset_ = 0; + } + + // A external typed data or a view on an external typed data. + const TypedDataBase* typed_data_ = nullptr; + + // The raw data size/length of [typed_data_]. + const uint8_t* raw_buffer_ = nullptr; + intptr_t size_ = 0; + + intptr_t offset_ = 0; +}; + +// A helper class that saves the current reader position, goes to another reader +// position, and upon destruction, resets to the original reader position. +class AlternativeReadingScope { + public: + AlternativeReadingScope(Reader* reader, intptr_t new_position) + : reader_(reader), saved_offset_(reader_->offset_) { + reader_->offset_ = new_position; + } + + ~AlternativeReadingScope() { reader_->offset_ = saved_offset_; } + + private: + Reader* const reader_; + const intptr_t saved_offset_; + + DISALLOW_COPY_AND_ASSIGN(AlternativeReadingScope); +}; + +// Helper class for reading bytecode. +class BytecodeReaderHelper : public ValueObject { + public: + explicit BytecodeReaderHelper(Thread* thread, + const TypedDataBase& typed_data); + + explicit BytecodeReaderHelper(Thread* thread, + BytecodeComponentData* bytecode_component); + + Reader& reader() { return reader_; } + + void ReadCode(const Function& function, intptr_t code_offset); + + void ReadMembers(const Class& cls, bool discard_fields); + + void ReadFieldDeclarations(const Class& cls, bool discard_fields); + void ReadFunctionDeclarations(const Class& cls); + void ReadClassDeclaration(const Class& cls); + void ReadLibraryDeclaration(const Library& library, + bool lookup_classes, + const GrowableObjectArray& pending_classes); + void ReadLibraryDeclarations(intptr_t num_libraries); + + LibraryPtr ReadMain(); + + ArrayPtr ReadBytecodeComponent(); + void ResetObjects(); + + // Fills in [is_covariant] and [is_generic_covariant_impl] vectors + // according to covariance attributes of [function] parameters. + // + // [function] should be declared in bytecode. + // [is_covariant] and [is_generic_covariant_impl] should contain bitvectors + // of function.NumParameters() length. + void ReadParameterCovariance(const Function& function, + intptr_t code_offset, + BitVector* is_covariant, + BitVector* is_generic_covariant_impl); + + // Read bytecode PackedObject. + ObjectPtr ReadObject(); + + private: + // These constants should match corresponding constants in class ObjectHandle + // (pkg/dart2bytecode/lib/object_table.dart). + static const int kReferenceBit = 1 << 0; + static const int kIndexShift = 1; + static const int kKindShift = 1; + static const int kKindMask = 0x0f; + static const int kFlagBit0 = 1 << 5; + static const int kFlagBit1 = 1 << 6; + static const int kFlagBit2 = 1 << 7; + static const int kFlagBit3 = 1 << 8; + static const int kFlagBit4 = 1 << 9; + static const int kFlagBit5 = 1 << 10; + static const int kTagMask = (kFlagBit0 | kFlagBit1 | kFlagBit2 | kFlagBit3); + static const int kFlagIsNullable = kFlagBit4; + static const int kFlagsMask = (kTagMask | kFlagBit4 | kFlagBit5); + + // Code flags, must be in sync with Code constants in + // pkg/dart2bytecode/lib/declarations.dart. + struct Code { + static const int kHasExceptionsTableFlag = 1 << 0; + static const int kHasSourcePositionsFlag = 1 << 1; + static const int kHasNullableFieldsFlag = 1 << 2; + static const int kHasClosuresFlag = 1 << 3; + static const int kHasParameterFlagsFlag = 1 << 4; + static const int kHasForwardingStubTargetFlag = 1 << 5; + static const int kHasDefaultFunctionTypeArgsFlag = 1 << 6; + static const int kHasLocalVariablesFlag = 1 << 7; + }; + + // Closure code flags, must be in sync with ClosureCode constants in + // pkg/dart2bytecode/lib/declarations.dart. + struct ClosureCode { + static const int kHasExceptionsTableFlag = 1 << 0; + static const int kHasSourcePositionsFlag = 1 << 1; + static const int kHasLocalVariablesFlag = 1 << 2; + }; + + // Parameter flags, must be in sync with ParameterDeclaration constants in + // pkg/dart2bytecode/lib/declarations.dart. + struct Parameter { + static const int kIsCovariantFlag = 1 << 0; + static const int kIsGenericCovariantImplFlag = 1 << 1; + static const int kIsFinalFlag = 1 << 2; + static const int kIsRequiredFlag = 1 << 3; + }; + + class FunctionTypeScope : public ValueObject { + public: + explicit FunctionTypeScope(BytecodeReaderHelper* bytecode_reader, + const FunctionType& type) + : bytecode_reader_(bytecode_reader) { + bytecode_reader_->enclosing_function_types_.Add(&type); + } + + ~FunctionTypeScope() { + bytecode_reader_->enclosing_function_types_.RemoveLast(); + } + + private: + BytecodeReaderHelper* const bytecode_reader_; + }; + + class FunctionScope : public ValueObject { + public: + FunctionScope(BytecodeReaderHelper* bytecode_reader, + const Function& function, + const String& name, + const Class& cls) + : bytecode_reader_(bytecode_reader) { + ASSERT(bytecode_reader_->scoped_function_.IsNull()); + ASSERT(bytecode_reader_->scoped_function_name_.IsNull()); + ASSERT(bytecode_reader_->scoped_function_class_.IsNull()); + ASSERT(name.IsSymbol()); + bytecode_reader_->scoped_function_ = function.ptr(); + bytecode_reader_->scoped_function_name_ = name.ptr(); + bytecode_reader_->scoped_function_class_ = cls.ptr(); + } + + ~FunctionScope() { + bytecode_reader_->scoped_function_ = Function::null(); + bytecode_reader_->scoped_function_name_ = String::null(); + bytecode_reader_->scoped_function_class_ = Class::null(); + } + + private: + BytecodeReaderHelper* bytecode_reader_; + }; + + void ReadClosureDeclaration(const Function& function, intptr_t closureIndex); + FunctionTypePtr ReadFunctionSignature(const FunctionType& signature, + bool has_optional_positional_params, + bool has_optional_named_params, + bool has_type_params, + bool has_positional_param_names, + bool has_parameter_flags); + void ReadTypeParametersDeclaration( + const Class& parameterized_class, + const FunctionType& parameterized_signature); + + // Read portion of constant pool corresponding to one function/closure. + // Start with [start_index], and stop when reaching EndClosureFunctionScope. + // Return index of the last read constant pool entry. + intptr_t ReadConstantPool(const Function& function, + const ObjectPool& pool, + intptr_t start_index); + + BytecodePtr ReadBytecode(const ObjectPool& pool); + void ReadExceptionsTable(const Function& function, + const Bytecode& bytecode, + bool has_exceptions_table); + void ReadSourcePositions(const Bytecode& bytecode, bool has_source_positions); + void ReadLocalVariables(const Bytecode& bytecode, bool has_local_variables); + StringPtr ConstructorName(const Class& cls, const String& name); + + ObjectPtr ReadObjectContents(uint32_t header); + ObjectPtr ReadConstObject(intptr_t tag); + ObjectPtr ReadType(intptr_t tag, Nullability nullability); + StringPtr ReadString(bool is_canonical = true); + TypeArgumentsPtr ReadTypeArguments(); + void SetupFieldAccessorFunction(const Class& klass, + const Function& function, + const AbstractType& field_type); + PatchClassPtr GetPatchClass(const Class& cls, const Script& script); + InstancePtr Canonicalize(const Instance& instance); + + // Similar to cls.EnsureClassDeclaration, but may be more efficient if + // class is from the current kernel binary. + void LoadReferencedClass(const Class& cls); + + Reader reader_; + Thread* const thread_; + Zone* const zone_; + BytecodeComponentData* bytecode_component_; + Array* closures_ = nullptr; + PatchClass* patch_class_ = nullptr; + Array* functions_ = nullptr; + intptr_t function_index_ = 0; + GrowableArray enclosing_function_types_; + Function& scoped_function_; + String& scoped_function_name_; + Class& scoped_function_class_; + + DISALLOW_COPY_AND_ASSIGN(BytecodeReaderHelper); +}; + +class BytecodeComponentData : ValueObject { + public: + enum { + kTypedData, + kVersion, + kStringsHeaderOffset, + kStringsContentsOffset, + kObjectOffsetsOffset, + kNumObjects, + kObjectsContentsOffset, + kMainOffset, + kNumLibraries, + kLibraryIndexOffset, + kLibrariesOffset, + kNumClasses, + kClassesOffset, + kMembersOffset, + kNumCodes, + kCodesOffset, + kSourcePositionsOffset, + kSourceFilesOffset, + kLineStartsOffset, + kLocalVariablesOffset, + kAnnotationsOffset, + kNumFields + }; + + explicit BytecodeComponentData(const Array& data) : data_(data) {} + + TypedDataBasePtr GetTypedData() const; + intptr_t GetVersion() const; + intptr_t GetStringsHeaderOffset() const; + intptr_t GetStringsContentsOffset() const; + intptr_t GetObjectOffsetsOffset() const; + intptr_t GetNumObjects() const; + intptr_t GetObjectsContentsOffset() const; + intptr_t GetMainOffset() const; + intptr_t GetNumLibraries() const; + intptr_t GetLibraryIndexOffset() const; + intptr_t GetLibrariesOffset() const; + intptr_t GetNumClasses() const; + intptr_t GetClassesOffset() const; + intptr_t GetMembersOffset() const; + intptr_t GetNumCodes() const; + intptr_t GetCodesOffset() const; + intptr_t GetSourcePositionsOffset() const; + intptr_t GetSourceFilesOffset() const; + intptr_t GetLineStartsOffset() const; + intptr_t GetLocalVariablesOffset() const; + intptr_t GetAnnotationsOffset() const; + void SetObject(intptr_t index, const Object& obj) const; + ObjectPtr GetObject(intptr_t index) const; + + bool IsNull() const { return data_.IsNull(); } + + static ArrayPtr New(Zone* zone, + const TypedDataBase& typed_data, + intptr_t version, + intptr_t num_objects, + intptr_t strings_header_offset, + intptr_t strings_contents_offset, + intptr_t object_offsets_offset, + intptr_t objects_contents_offset, + intptr_t main_offset, + intptr_t num_libraries, + intptr_t library_index_offset, + intptr_t libraries_offset, + intptr_t num_classes, + intptr_t classes_offset, + intptr_t members_offset, + intptr_t num_codes, + intptr_t codes_offset, + intptr_t source_positions_offset, + intptr_t source_files_offset, + intptr_t line_starts_offset, + intptr_t local_variables_offset, + intptr_t annotations_offset, + Heap::Space space); + + private: + const Array& data_; +}; + +class BytecodeReader : public AllStatic { + public: + // Read declaration of the given class. + static void LoadClassDeclaration(const Class& cls); + + // Read members of the given class. + static void FinishClassLoading(const Class& cls); + + static void ReadParameterCovariance(const Function& function, + BitVector* is_covariant, + BitVector* is_generic_covariant_impl); +}; + +class BytecodeSourcePositionsIterator : ValueObject { + public: + // These constants should match corresponding constants in class + // SourcePositions (pkg/dart2bytecode/lib/source_positions.dart). + static const intptr_t kSyntheticCodeMarker = -1; + static const intptr_t kYieldPointMarker = -2; + + BytecodeSourcePositionsIterator(Zone* zone, const Bytecode& bytecode) + : reader_(TypedDataBase::Handle(zone, bytecode.binary())) { + ASSERT(bytecode.HasSourcePositions()); + reader_.set_offset(bytecode.source_positions_binary_offset()); + pairs_remaining_ = reader_.ReadUInt(); + } + + bool MoveNext() { + if (pairs_remaining_ == 0) { + return false; + } + ASSERT(pairs_remaining_ > 0); + --pairs_remaining_; + cur_bci_ += reader_.ReadUInt(); + cur_token_pos_ += reader_.ReadSLEB128(); + is_yield_point_ = false; + if (cur_token_pos_ == kYieldPointMarker) { + const bool result = MoveNext(); + is_yield_point_ = true; + return result; + } + return true; + } + + uword PcOffset() const { return cur_bci_; } + + TokenPosition TokenPos() const { + return (cur_token_pos_ == kSyntheticCodeMarker) + ? TokenPosition::kNoSource + : TokenPosition::Deserialize(cur_token_pos_); + } + + bool IsYieldPoint() const { return is_yield_point_; } + + private: + Reader reader_; + intptr_t pairs_remaining_ = 0; + intptr_t cur_bci_ = 0; + intptr_t cur_token_pos_ = 0; + bool is_yield_point_ = false; +}; + +} // namespace bytecode +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) +#endif // RUNTIME_VM_BYTECODE_READER_H_ diff --git a/runtime/vm/class_finalizer.cc b/runtime/vm/class_finalizer.cc index 2a8365b625a..5a13e50639f 100644 --- a/runtime/vm/class_finalizer.cc +++ b/runtime/vm/class_finalizer.cc @@ -7,6 +7,7 @@ #include "vm/class_finalizer.h" +#include "vm/bytecode_reader.h" #include "vm/canonical_tables.h" #include "vm/closure_functions_cache.h" #include "vm/compiler/jit/compiler.h" @@ -436,7 +437,7 @@ AbstractTypePtr ClassFinalizer::FinalizeType(const AbstractType& type, } } -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) #if defined(TARGET_ARCH_X64) static bool IsPotentialExactGeneric(const AbstractType& type) { @@ -521,7 +522,7 @@ void ClassFinalizer::FinalizeMemberTypes(const Class& cls) { } } } -#endif // !defined(DART_PRECOMPILED_RUNTIME) +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) void ClassFinalizer::FinalizeTypesInClass(const Class& cls) { Thread* thread = Thread::Current(); @@ -531,9 +532,7 @@ void ClassFinalizer::FinalizeTypesInClass(const Class& cls) { return; } -#if defined(DART_PRECOMPILED_RUNTIME) - UNREACHABLE(); -#else +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) Zone* zone = thread->zone(); SafepointWriteRwLocker ml(thread, thread->isolate_group()->program_lock()); if (cls.is_type_finalized()) { @@ -585,6 +584,8 @@ void ClassFinalizer::FinalizeTypesInClass(const Class& cls) { cls.set_is_type_finalized(); cls.set_is_isolate_unsendable_due_to_pragma(has_isolate_unsendable_pragma); cls.set_is_future_subtype(is_future_subtype); + +#if !defined(DART_PRECOMPILED_RUNTIME) if (is_future_subtype && !cls.is_abstract()) { MarkClassCanBeFuture(zone, cls); } @@ -593,7 +594,11 @@ void ClassFinalizer::FinalizeTypesInClass(const Class& cls) { } ClassHiearchyUpdater(zone).Register(cls); -#endif // defined(DART_PRECOMPILED_RUNTIME) +#endif // !defined(DART_PRECOMPILED_RUNTIME) + +#else + UNREACHABLE(); +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) } #if !defined(DART_PRECOMPILED_RUNTIME) @@ -709,7 +714,7 @@ void ClassFinalizer::FinalizeClass(const Class& cls) { return; } -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); #else Thread* thread = Thread::Current(); @@ -729,9 +734,22 @@ void ClassFinalizer::FinalizeClass(const Class& cls) { #endif // defined(SUPPORT_TIMELINE) // If loading from a kernel, make sure that the class is fully loaded. - ASSERT(cls.IsTopLevel() || (cls.kernel_offset() > 0)); + ASSERT(cls.IsTopLevel() || cls.is_declared_in_bytecode() || + (cls.kernel_offset() > 0)); if (!cls.is_loaded()) { - kernel::KernelLoader::FinishLoading(cls); + if (cls.is_declared_in_bytecode()) { +#if defined(DART_DYNAMIC_MODULES) + bytecode::BytecodeReader::FinishClassLoading(cls); +#else + UNREACHABLE(); +#endif + } else { +#if defined(DART_PRECOMPILED_RUNTIME) + UNREACHABLE(); +#else + kernel::KernelLoader::FinishLoading(cls); +#endif + } if (cls.is_finalized()) { return; } @@ -747,9 +765,11 @@ void ClassFinalizer::FinalizeClass(const Class& cls) { } // Mark as loaded and finalized. cls.Finalize(); +#if !defined(DART_PRECOMPILED_RUNTIME) if (FLAG_print_classes) { PrintClassInformation(cls); } +#endif FinalizeMemberTypes(cls); // The rest of finalization for non-top-level class has to be done with @@ -758,7 +778,15 @@ void ClassFinalizer::FinalizeClass(const Class& cls) { if (cls.IsTopLevel()) { cls.set_is_allocate_finalized(); } + +#if defined(DART_PRECOMPILED_RUNTIME) + // Allocate-finalization is a no-op in AOT, so + // mark finalized classed as allocate-finalized eagerly. + if (!cls.is_allocate_finalized()) { + cls.set_is_allocate_finalized(); + } #endif // defined(DART_PRECOMPILED_RUNTIME) +#endif // defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) } #if !defined(DART_PRECOMPILED_RUNTIME) @@ -814,15 +842,16 @@ ErrorPtr ClassFinalizer::AllocateFinalizeClass(const Class& cls) { return Error::null(); } +#endif // !defined(DART_PRECOMPILED_RUNTIME) + +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) ErrorPtr ClassFinalizer::LoadClassMembers(const Class& cls) { ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); ASSERT(!cls.is_finalized()); LongJumpScope jump; if (setjmp(*jump.Set()) == 0) { -#if !defined(DART_PRECOMPILED_RUNTIME) cls.EnsureDeclarationLoaded(); -#endif ASSERT(cls.is_type_finalized()); ClassFinalizer::FinalizeClass(cls); return Error::null(); @@ -830,6 +859,9 @@ ErrorPtr ClassFinalizer::LoadClassMembers(const Class& cls) { return Thread::Current()->StealStickyError(); } } +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) + +#if !defined(DART_PRECOMPILED_RUNTIME) void ClassFinalizer::PrintClassInformation(const Class& cls) { Thread* thread = Thread::Current(); diff --git a/runtime/vm/class_finalizer.h b/runtime/vm/class_finalizer.h index e6b29552a06..c575c9ecf00 100644 --- a/runtime/vm/class_finalizer.h +++ b/runtime/vm/class_finalizer.h @@ -68,13 +68,17 @@ class ClassFinalizer : public AllStatic { #if !defined(DART_PRECOMPILED_RUNTIME) // Makes class instantiatable and usable by generated code. static ErrorPtr AllocateFinalizeClass(const Class& cls); +#endif // !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) // Completes loading of the class, this populates the function // and fields of the class. // // Returns Error::null() if there is no loading error. static ErrorPtr LoadClassMembers(const Class& cls); +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) +#if !defined(DART_PRECOMPILED_RUNTIME) // Verify that the classes have been properly prefinalized. This is // needed during bootstrapping where the classes have been preloaded. static void VerifyBootstrapClasses(); @@ -91,8 +95,10 @@ class ClassFinalizer : public AllStatic { const TypeParameters& type_params, FinalizationKind finalization); -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) static void FinalizeMemberTypes(const Class& cls); +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) +#if !defined(DART_PRECOMPILED_RUNTIME) static void PrintClassInformation(const Class& cls); #endif // !defined(DART_PRECOMPILED_RUNTIME) diff --git a/runtime/vm/class_id.h b/runtime/vm/class_id.h index c0b4ec9587d..2a3335377a5 100644 --- a/runtime/vm/class_id.h +++ b/runtime/vm/class_id.h @@ -38,6 +38,7 @@ static constexpr intptr_t kClassIdTagMax = (1 << 20) - 1; V(WeakSerializationReference) \ V(WeakArray) \ V(Code) \ + V(Bytecode) \ V(Instructions) \ V(InstructionsSection) \ V(InstructionsTable) \ diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc index dca8ce21820..68be5c9d519 100644 --- a/runtime/vm/compiler/aot/precompiler.cc +++ b/runtime/vm/compiler/aot/precompiler.cc @@ -1948,8 +1948,15 @@ void Precompiler::TraceForRetainedFunctions() { function ^= functions.At(j); function.DropUncompiledImplicitClosureFunction(); - const bool retained = - possibly_retained_functions_.ContainsKey(function); + bool retained = possibly_retained_functions_.ContainsKey(function); +#if defined(DART_DYNAMIC_MODULES) + // Retain abstract functions annotated with entry point + // pragmas as they can be used as targets of interface calls. + if (function.is_abstract() && + functions_with_entry_point_pragmas_.ContainsKey(function)) { + retained = true; + } +#endif // defined(DART_DYNAMIC_MODULES) if (retained) { AddTypesOf(function); } @@ -2575,6 +2582,14 @@ void Precompiler::DropTransitiveUserDefinedConstants() { if (cls.constants() == Array::null()) { continue; } +#if defined(DART_DYNAMIC_MODULES) + // Retain constant tables of exported classes to allow constant + // canonicalization at runtime. + if (HasApiUse(cls)) { + continue; + } +#endif // defined(DART_DYNAMIC_MODULES) + typedef UnorderedHashSet CanonicalInstancesSet; CanonicalInstancesSet constants_set(cls.constants()); diff --git a/runtime/vm/compiler/asm_intrinsifier_riscv.cc b/runtime/vm/compiler/asm_intrinsifier_riscv.cc index 8a7a588238f..54c4ea67a78 100644 --- a/runtime/vm/compiler/asm_intrinsifier_riscv.cc +++ b/runtime/vm/compiler/asm_intrinsifier_riscv.cc @@ -2017,7 +2017,7 @@ void AsmIntrinsifier::Timeline_isDartStreamEnabled(Assembler* assembler, #else Label true_label; // Load TimelineStream*. - __ lx(A0, Address(THR, target::Thread::dart_stream_offset())); + __ LoadFromOffset(A0, THR, target::Thread::dart_stream_offset()); // Load uintptr_t from TimelineStream*. __ lx(A0, Address(A0, target::TimelineStream::enabled_offset())); __ bnez(A0, &true_label, Assembler::kNearJump); diff --git a/runtime/vm/compiler/assembler/disassembler_kbc.cc b/runtime/vm/compiler/assembler/disassembler_kbc.cc new file mode 100644 index 00000000000..6b3229f7e60 --- /dev/null +++ b/runtime/vm/compiler/assembler/disassembler_kbc.cc @@ -0,0 +1,414 @@ +// Copyright (c) 2024, 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/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/compiler/assembler/disassembler_kbc.h" + +#include "platform/assert.h" +#include "vm/bytecode_reader.h" +#include "vm/constants_kbc.h" + +namespace dart { + +static const char* kOpcodeNames[] = { +#define BYTECODE_NAME(name, encoding, kind, op1, op2, op3) #name, + KERNEL_BYTECODES_LIST(BYTECODE_NAME) +#undef BYTECODE_NAME +}; + +static const size_t kOpcodeCount = + sizeof(kOpcodeNames) / sizeof(kOpcodeNames[0]); +static_assert(kOpcodeCount <= 256, "Opcode should fit into a byte"); + +typedef void (*BytecodeFormatter)(char* buffer, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr); +typedef void (*Fmt)(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value); + +template +void FormatOperand(char** buf, + intptr_t* size, + const char* fmt, + ValueType value) { + intptr_t written = Utils::SNPrint(*buf, *size, fmt, value); + if (written < *size) { + *buf += written; + *size += written; + } else { + *size = -1; + } +} + +static void Fmt___(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) {} + +static void Fmttgt(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) { + if (FLAG_disassemble_relative) { + FormatOperand(buf, size, "-> %" Pd, value); + } else { + FormatOperand(buf, size, "-> %" Px, instr + value); + } +} + +static void Fmtlit(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) { + FormatOperand(buf, size, "k%d", value); +} + +static void Fmtreg(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) { + FormatOperand(buf, size, "r%d", value); +} + +static void Fmtxeg(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) { + if (value < 0) { + FormatOperand(buf, size, "FP[%d]", value); + } else { + Fmtreg(buf, size, instr, value); + } +} + +static void Fmtnum(char** buf, + intptr_t* size, + const KBCInstr* instr, + int32_t value) { + FormatOperand(buf, size, "#%d", value); +} + +static void Apply(char** buf, + intptr_t* size, + const KBCInstr* instr, + Fmt fmt, + int32_t value, + const char* suffix) { + if (*size <= 0) { + return; + } + + fmt(buf, size, instr, value); + if (*size > 0) { + FormatOperand(buf, size, "%s", suffix); + } +} + +static void Format0(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) {} + +static void FormatA(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t a = KernelBytecode::DecodeA(instr); + Apply(&buf, &size, instr, op1, a, ""); +} + +static void FormatD(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t bc = KernelBytecode::DecodeD(instr); + Apply(&buf, &size, instr, op1, bc, ""); +} + +static void FormatX(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t bc = KernelBytecode::DecodeX(instr); + Apply(&buf, &size, instr, op1, bc, ""); +} + +static void FormatT(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t x = KernelBytecode::DecodeT(instr); + Apply(&buf, &size, instr, op1, x, ""); +} + +static void FormatA_E(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t a = KernelBytecode::DecodeA(instr); + const int32_t e = KernelBytecode::DecodeE(instr); + Apply(&buf, &size, instr, op1, a, ", "); + Apply(&buf, &size, instr, op2, e, ""); +} + +static void FormatA_Y(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t a = KernelBytecode::DecodeA(instr); + const int32_t y = KernelBytecode::DecodeY(instr); + Apply(&buf, &size, instr, op1, a, ", "); + Apply(&buf, &size, instr, op2, y, ""); +} + +static void FormatD_F(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t d = KernelBytecode::DecodeD(instr); + const int32_t f = KernelBytecode::DecodeF(instr); + Apply(&buf, &size, instr, op1, d, ", "); + Apply(&buf, &size, instr, op2, f, ""); +} + +static void FormatA_B_C(char* buf, + intptr_t size, + KernelBytecode::Opcode opcode, + const KBCInstr* instr, + Fmt op1, + Fmt op2, + Fmt op3) { + const int32_t a = KernelBytecode::DecodeA(instr); + const int32_t b = KernelBytecode::DecodeB(instr); + const int32_t c = KernelBytecode::DecodeC(instr); + Apply(&buf, &size, instr, op1, a, ", "); + Apply(&buf, &size, instr, op2, b, ", "); + Apply(&buf, &size, instr, op3, c, ""); +} + +#define BYTECODE_FORMATTER(name, encoding, kind, op1, op2, op3) \ + static void Format##name(char* buf, intptr_t size, \ + KernelBytecode::Opcode opcode, \ + const KBCInstr* instr) { \ + Format##encoding(buf, size, opcode, instr, Fmt##op1, Fmt##op2, Fmt##op3); \ + } +KERNEL_BYTECODES_LIST(BYTECODE_FORMATTER) +#undef BYTECODE_FORMATTER + +static const BytecodeFormatter kFormatters[] = { +#define BYTECODE_FORMATTER(name, encoding, kind, op1, op2, op3) &Format##name, + KERNEL_BYTECODES_LIST(BYTECODE_FORMATTER) +#undef BYTECODE_FORMATTER +}; + +static intptr_t GetConstantPoolIndex(const KBCInstr* instr) { + switch (KernelBytecode::DecodeOpcode(instr)) { + case KernelBytecode::kLoadConstant: + case KernelBytecode::kLoadConstant_Wide: + case KernelBytecode::kInstantiateTypeArgumentsTOS: + case KernelBytecode::kInstantiateTypeArgumentsTOS_Wide: + case KernelBytecode::kAssertAssignable: + case KernelBytecode::kAssertAssignable_Wide: + return KernelBytecode::DecodeE(instr); + + case KernelBytecode::kPushConstant: + case KernelBytecode::kPushConstant_Wide: + case KernelBytecode::kInitLateField: + case KernelBytecode::kInitLateField_Wide: + case KernelBytecode::kStoreStaticTOS: + case KernelBytecode::kStoreStaticTOS_Wide: + case KernelBytecode::kLoadStatic: + case KernelBytecode::kLoadStatic_Wide: + case KernelBytecode::kAllocate: + case KernelBytecode::kAllocate_Wide: + case KernelBytecode::kAllocateClosure: + case KernelBytecode::kAllocateClosure_Wide: + case KernelBytecode::kInstantiateType: + case KernelBytecode::kInstantiateType_Wide: + case KernelBytecode::kDirectCall: + case KernelBytecode::kDirectCall_Wide: + case KernelBytecode::kUncheckedDirectCall: + case KernelBytecode::kUncheckedDirectCall_Wide: + case KernelBytecode::kInterfaceCall: + case KernelBytecode::kInterfaceCall_Wide: + case KernelBytecode::kInstantiatedInterfaceCall: + case KernelBytecode::kInstantiatedInterfaceCall_Wide: + case KernelBytecode::kUncheckedClosureCall: + case KernelBytecode::kUncheckedClosureCall_Wide: + case KernelBytecode::kUncheckedInterfaceCall: + case KernelBytecode::kUncheckedInterfaceCall_Wide: + case KernelBytecode::kDynamicCall: + case KernelBytecode::kDynamicCall_Wide: + return KernelBytecode::DecodeD(instr); + + default: + return -1; + } +} + +static bool GetLoadedObjectAt(uword pc, + const ObjectPool& object_pool, + Object* obj) { + const KBCInstr* instr = reinterpret_cast(pc); + const intptr_t index = GetConstantPoolIndex(instr); + if (index >= 0) { + if (object_pool.TypeAt(index) == ObjectPool::EntryType::kTaggedObject) { + *obj = object_pool.ObjectAt(index); + return true; + } + } + return false; +} + +void KernelBytecodeDisassembler::DecodeInstruction(char* hex_buffer, + intptr_t hex_size, + char* human_buffer, + intptr_t human_size, + int* out_instr_size, + const Bytecode& bytecode, + Object** object, + uword pc) { + const KBCInstr* instr = reinterpret_cast(pc); + const KernelBytecode::Opcode opcode = KernelBytecode::DecodeOpcode(instr); + const intptr_t instr_size = KernelBytecode::kInstructionSize[opcode]; + + size_t name_size = + Utils::SNPrint(human_buffer, human_size, "%-10s\t", kOpcodeNames[opcode]); + human_buffer += name_size; + human_size -= name_size; + kFormatters[opcode](human_buffer, human_size, opcode, instr); + + const intptr_t kCharactersPerByte = 3; + if (hex_size > instr_size * kCharactersPerByte) { + for (intptr_t i = 0; i < instr_size; ++i) { + Utils::SNPrint(hex_buffer + (i * kCharactersPerByte), + hex_size - (i * kCharactersPerByte), " %02x", instr[i]); + } + } + if (out_instr_size != nullptr) { + *out_instr_size = instr_size; + } + + *object = NULL; + if (!bytecode.IsNull()) { + *object = &Object::Handle(); + const ObjectPool& pool = ObjectPool::Handle(bytecode.object_pool()); + if (!GetLoadedObjectAt(pc, pool, *object)) { + *object = NULL; + } + } +} + +void KernelBytecodeDisassembler::Disassemble(uword start, + uword end, + DisassemblyFormatter* formatter, + const Bytecode& bytecode) { +#if !defined(PRODUCT) + ASSERT(formatter != NULL); + char hex_buffer[kHexadecimalBufferSize]; // Instruction in hexadecimal form. + char human_buffer[kUserReadableBufferSize]; // Human-readable instruction. + uword pc = start; + GrowableArray inlined_functions; + GrowableArray token_positions; + while (pc < end) { + int instruction_length; + Object* object; + DecodeInstruction(hex_buffer, sizeof(hex_buffer), human_buffer, + sizeof(human_buffer), &instruction_length, bytecode, + &object, pc); + formatter->ConsumeInstruction(hex_buffer, sizeof(hex_buffer), human_buffer, + sizeof(human_buffer), object, + FLAG_disassemble_relative ? pc - start : pc); + pc += instruction_length; + } +#else + UNREACHABLE(); +#endif +} + +void KernelBytecodeDisassembler::Disassemble(const Function& function) { +#if !defined(PRODUCT) + ASSERT(function.HasBytecode()); + const char* function_fullname = function.ToFullyQualifiedCString(); + Zone* zone = Thread::Current()->zone(); + const Bytecode& bytecode = Bytecode::Handle(zone, function.GetBytecode()); + THR_Print("Bytecode for function '%s' {\n", function_fullname); + const uword start = bytecode.PayloadStart(); + const uword base = FLAG_disassemble_relative ? 0 : start; + DisassembleToStdout stdout_formatter; + LogBlock lb; + Disassemble(start, start + bytecode.Size(), &stdout_formatter, bytecode); + THR_Print("}\n"); + + const ObjectPool& object_pool = + ObjectPool::Handle(zone, bytecode.object_pool()); + object_pool.DebugPrint(); + + THR_Print("PC Descriptors for function '%s' {\n", function_fullname); + const PcDescriptors& descriptors = + PcDescriptors::Handle(zone, bytecode.pc_descriptors()); + THR_Print("%s}\n", descriptors.ToCString()); + + if (bytecode.HasSourcePositions()) { + THR_Print("Source positions for function '%s' {\n", function_fullname); + // 4 bits per hex digit + 2 for "0x". + const int addr_width = (kBitsPerWord / 4) + 2; + // "*" in a printf format specifier tells it to read the field width from + // the printf argument list. + THR_Print("%-*s\tpos\tline\tcolumn\tyield\n", addr_width, "pc"); + const Script& script = Script::Handle(zone, function.script()); + bytecode::BytecodeSourcePositionsIterator iter(zone, bytecode); + while (iter.MoveNext()) { + TokenPosition pos = iter.TokenPos(); + intptr_t line = -1, column = -1; + script.GetTokenLocation(pos, &line, &column); + THR_Print("%#-*" Px "\t%s\t%" Pd "\t%" Pd "\t%s\n", addr_width, + base + iter.PcOffset(), pos.ToCString(), line, column, + iter.IsYieldPoint() ? "yield" : ""); + } + THR_Print("}\n"); + } + + THR_Print("Exception Handlers for function '%s' {\n", function_fullname); + const ExceptionHandlers& handlers = + ExceptionHandlers::Handle(zone, bytecode.exception_handlers()); + THR_Print("%s}\n", handlers.ToCString()); + +#else + UNREACHABLE(); +#endif +} + +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) diff --git a/runtime/vm/compiler/assembler/disassembler_kbc.h b/runtime/vm/compiler/assembler/disassembler_kbc.h new file mode 100644 index 00000000000..c54d6588a01 --- /dev/null +++ b/runtime/vm/compiler/assembler/disassembler_kbc.h @@ -0,0 +1,89 @@ +// Copyright (c) 2024, 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_ASSEMBLER_DISASSEMBLER_KBC_H_ +#define RUNTIME_VM_COMPILER_ASSEMBLER_DISASSEMBLER_KBC_H_ + +#include "vm/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/compiler/assembler/disassembler.h" + +namespace dart { + +// Disassemble instructions. +class KernelBytecodeDisassembler : public AllStatic { + public: + // Disassemble instructions between start and end. + // (The assumption is that start is at a valid instruction). + // Return true if all instructions were successfully decoded, false otherwise. + static void Disassemble(uword start, + uword end, + DisassemblyFormatter* formatter, + const Bytecode& bytecode); + + static void Disassemble(uword start, + uword end, + DisassemblyFormatter* formatter) { + Disassemble(start, end, formatter, Bytecode::Handle()); + } + + static void Disassemble(uword start, uword end, const Bytecode& bytecode) { +#if !defined(PRODUCT) + DisassembleToStdout stdout_formatter; + LogBlock lb; + Disassemble(start, end, &stdout_formatter, bytecode); +#else + UNREACHABLE(); +#endif + } + + static void Disassemble(uword start, uword end) { +#if !defined(PRODUCT) + DisassembleToStdout stdout_formatter; + LogBlock lb; + Disassemble(start, end, &stdout_formatter); +#else + UNREACHABLE(); +#endif + } + + static void Disassemble(uword start, + uword end, + char* buffer, + uintptr_t buffer_size) { +#if !defined(PRODUCT) + DisassembleToMemory memory_formatter(buffer, buffer_size); + LogBlock lb; + Disassemble(start, end, &memory_formatter); +#else + UNREACHABLE(); +#endif + } + + // Decodes one instruction. + // Writes a hexadecimal representation into the hex_buffer and a + // human-readable representation into the human_buffer. + // Writes the length of the decoded instruction in bytes in out_instr_len. + static void DecodeInstruction(char* hex_buffer, + intptr_t hex_size, + char* human_buffer, + intptr_t human_size, + int* out_instr_len, + const Bytecode& bytecode, + Object** object, + uword pc); + + static void Disassemble(const Function& function); + + private: + static const int kHexadecimalBufferSize = 32; + static const int kUserReadableBufferSize = 256; +}; + +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) + +#endif // RUNTIME_VM_COMPILER_ASSEMBLER_DISASSEMBLER_KBC_H_ diff --git a/runtime/vm/compiler/backend/il_arm.cc b/runtime/vm/compiler/backend/il_arm.cc index 8528cc53c8f..9a8794e6f4c 100644 --- a/runtime/vm/compiler/backend/il_arm.cc +++ b/runtime/vm/compiler/backend/il_arm.cc @@ -809,6 +809,11 @@ void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) { // R0: Closure with a cached entry point. __ ldr(R2, compiler::FieldAddress( R0, compiler::target::Closure::entry_point_offset())); +#if defined(DART_DYNAMIC_MODULES) + ASSERT(FUNCTION_REG != R2); + __ ldr(FUNCTION_REG, compiler::FieldAddress( + R0, compiler::target::Closure::function_offset())); +#endif } else { ASSERT(locs()->in(0).reg() == FUNCTION_REG); // FUNCTION_REG: Function. diff --git a/runtime/vm/compiler/backend/il_arm64.cc b/runtime/vm/compiler/backend/il_arm64.cc index 5205cace276..071541edc7c 100644 --- a/runtime/vm/compiler/backend/il_arm64.cc +++ b/runtime/vm/compiler/backend/il_arm64.cc @@ -651,6 +651,11 @@ void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) { // R0: Closure with a cached entry point. __ LoadFieldFromOffset(R2, R0, compiler::target::Closure::entry_point_offset()); +#if defined(DART_DYNAMIC_MODULES) + ASSERT(FUNCTION_REG != R2); + __ LoadCompressedFieldFromOffset( + FUNCTION_REG, R0, compiler::target::Closure::function_offset()); +#endif } else { ASSERT(locs()->in(0).reg() == FUNCTION_REG); // FUNCTION_REG: Function. diff --git a/runtime/vm/compiler/backend/il_riscv.cc b/runtime/vm/compiler/backend/il_riscv.cc index 7bfde9d84fc..2529e6db979 100644 --- a/runtime/vm/compiler/backend/il_riscv.cc +++ b/runtime/vm/compiler/backend/il_riscv.cc @@ -700,6 +700,11 @@ void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) { // T0: Closure with a cached entry point. __ LoadFieldFromOffset(A1, T0, compiler::target::Closure::entry_point_offset()); +#if defined(DART_DYNAMIC_MODULES) + ASSERT(FUNCTION_REG != A1); + __ LoadCompressedFieldFromOffset( + FUNCTION_REG, T0, compiler::target::Closure::function_offset()); +#endif } else { ASSERT(locs()->in(0).reg() == FUNCTION_REG); // FUNCTION_REG: Function. diff --git a/runtime/vm/compiler/backend/il_x64.cc b/runtime/vm/compiler/backend/il_x64.cc index 276aec21aee..ce7831d4f18 100644 --- a/runtime/vm/compiler/backend/il_x64.cc +++ b/runtime/vm/compiler/backend/il_x64.cc @@ -6615,6 +6615,12 @@ void ClosureCallInstr::EmitNativeCode(FlowGraphCompiler* compiler) { // RAX: Closure with cached entry point. __ movq(RCX, compiler::FieldAddress( RAX, compiler::target::Closure::entry_point_offset())); +#if defined(DART_DYNAMIC_MODULES) + ASSERT(FUNCTION_REG != RCX); + __ LoadCompressed(FUNCTION_REG, + compiler::FieldAddress( + RAX, compiler::target::Closure::function_offset())); +#endif } else { ASSERT(locs()->in(0).reg() == FUNCTION_REG); // FUNCTION_REG: Function. diff --git a/runtime/vm/compiler/compiler_sources.gni b/runtime/vm/compiler/compiler_sources.gni index 8e4e07ba993..a1d9746ed23 100644 --- a/runtime/vm/compiler/compiler_sources.gni +++ b/runtime/vm/compiler/compiler_sources.gni @@ -205,6 +205,8 @@ disassembler_sources = [ "assembler/disassembler.h", "assembler/disassembler_arm.cc", "assembler/disassembler_arm64.cc", + "assembler/disassembler_kbc.cc", + "assembler/disassembler_kbc.h", "assembler/disassembler_riscv.cc", "assembler/disassembler_x86.cc", ] diff --git a/runtime/vm/compiler/frontend/kernel_to_il.cc b/runtime/vm/compiler/frontend/kernel_to_il.cc index c77afdfce4d..87956ccfd71 100644 --- a/runtime/vm/compiler/frontend/kernel_to_il.cc +++ b/runtime/vm/compiler/frontend/kernel_to_il.cc @@ -798,6 +798,7 @@ LocalVariable* FlowGraphBuilder::LookupVariable(intptr_t kernel_offset) { FlowGraph* FlowGraphBuilder::BuildGraph() { const Function& function = parsed_function_->function(); + ASSERT(!function.is_declared_in_bytecode()); #ifdef DEBUG // Check that all functions that are explicitly marked as recognized with the diff --git a/runtime/vm/compiler/frontend/kernel_translation_helper.h b/runtime/vm/compiler/frontend/kernel_translation_helper.h index 3b97724486d..25fc128535f 100644 --- a/runtime/vm/compiler/frontend/kernel_translation_helper.h +++ b/runtime/vm/compiler/frontend/kernel_translation_helper.h @@ -1390,7 +1390,6 @@ class KernelReaderHelper { friend class VariableDeclarationHelper; friend class ObfuscationProhibitionsMetadataHelper; friend class LoadingUnitsMetadataHelper; - friend bool NeedsDynamicInvocationForwarder(const Function& function); friend ArrayPtr CollectConstConstructorCoverageFrom( const Script& interesting_script); diff --git a/runtime/vm/compiler/runtime_api.h b/runtime/vm/compiler/runtime_api.h index 1832df0210f..240546ec8f4 100644 --- a/runtime/vm/compiler/runtime_api.h +++ b/runtime/vm/compiler/runtime_api.h @@ -877,6 +877,12 @@ class KernelProgramInfo : public AllStatic { FINAL_CLASS(); }; +class Bytecode : public AllStatic { + public: + static word InstanceSize(); + FINAL_CLASS(); +}; + class PcDescriptors : public AllStatic { public: static word HeaderSize(); @@ -1215,6 +1221,8 @@ class Thread : public AllStatic { static word slow_type_test_stub_offset(); static word call_to_runtime_stub_offset(); static word invoke_dart_code_stub_offset(); + static word interpret_call_entry_point_offset(); + static word invoke_dart_code_from_bytecode_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(); diff --git a/runtime/vm/compiler/runtime_offsets_extracted.h b/runtime/vm/compiler/runtime_offsets_extracted.h index bac6e16985f..b441bafda60 100644 --- a/runtime/vm/compiler/runtime_offsets_extracted.h +++ b/runtime/vm/compiler/runtime_offsets_extracted.h @@ -323,219 +323,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x388; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x38c; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3a8; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3ac; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3c8; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3cc; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3ec; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3ac; + Thread_double_truncate_round_supported_offset = 0x3cc; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3d0; + Thread_service_extension_stream_offset = 0x3f0; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x39c; + 0x3bc; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x390; + 0x3b0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x3a4; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x350; + 0x3c4; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x370; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x354; + 0x374; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x368; + Thread_old_marking_stack_block_offset = 0x388; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x36c; + Thread_new_marking_stack_block_offset = 0x38c; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x394; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3b4; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x398; + Thread_saved_shadow_call_stack_offset = 0x3b8; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x3a0; + 0x3c0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x358; + 0x378; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x35c; + Thread_stack_overflow_flags_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x364; + 0x384; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x328; + Thread_suspend_state_await_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x32c; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x324; + Thread_suspend_state_init_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x330; + Thread_suspend_state_return_async_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x334; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x338; + Thread_suspend_state_init_async_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x33c; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x340; + Thread_suspend_state_return_async_star_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x344; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x364; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x348; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x368; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x34c; + Thread_suspend_state_handle_exception_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x360; + Thread_top_exit_frame_info_offset = 0x380; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x378; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x374; + Thread_unboxed_runtime_arg_offset = 0x398; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x394; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3b0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3b8; + 0x3d0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x3d8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3c0; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3e0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -620,12 +624,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, 0x314, -1, 0x318, -1, - 0x31c, 0x320, -1, -1, -1, -1, -1, -1}; + 0x324, 0x328, 0x32c, 0x330, 0x334, -1, 0x338, -1, + 0x33c, 0x340, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x78; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -1038,219 +1043,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x718; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x720; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x758; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x760; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x798; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x790; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d0; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x760; + Thread_double_truncate_round_supported_offset = 0x7a0; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x798; + Thread_service_extension_stream_offset = 0x7d8; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x740; + 0x780; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x728; + 0x768; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x750; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6b8; + 0x790; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6f8; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6c0; + 0x700; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x6e8; + Thread_old_marking_stack_block_offset = 0x728; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x6f0; + Thread_new_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x730; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x770; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x738; + Thread_saved_shadow_call_stack_offset = 0x778; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x748; + 0x788; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x6d0; + Thread_stack_overflow_flags_offset = 0x710; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x6e0; + 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x668; + Thread_suspend_state_await_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x670; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x660; + Thread_suspend_state_init_async_entry_point_offset = 0x6a0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x678; + Thread_suspend_state_return_async_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x680; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x688; + Thread_suspend_state_init_async_star_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x690; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x698; + Thread_suspend_state_return_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a0; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6a8; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6b0; + Thread_suspend_state_handle_exception_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x6d8; + Thread_top_exit_frame_info_offset = 0x718; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x708; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x700; + Thread_unboxed_runtime_arg_offset = 0x748; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x740; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x768; -static constexpr dart::compiler::target::word Thread_random_offset = 0x770; + 0x7a8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7b0; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x778; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7b8; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -1339,12 +1348,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, -1, -1, 0x628, 0x630, - 0x638, 0x640, 0x648, -1, 0x650, 0x658, -1, -1}; + 0x648, 0x650, 0x658, 0x660, -1, -1, 0x668, 0x670, + 0x678, 0x680, 0x688, -1, 0x690, 0x698, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc8; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -1753,219 +1763,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x380; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x384; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3a0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3a4; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3c0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3c4; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3e4; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3a4; + Thread_double_truncate_round_supported_offset = 0x3c4; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3c8; + Thread_service_extension_stream_offset = 0x3e8; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x394; + 0x3b4; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x388; + 0x3a8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x39c; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x344; + 0x3bc; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x364; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x348; + 0x368; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x35c; + Thread_old_marking_stack_block_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x360; + Thread_new_marking_stack_block_offset = 0x380; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x38c; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3ac; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x390; + Thread_saved_shadow_call_stack_offset = 0x3b0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x398; + 0x3b8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x34c; + 0x36c; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x350; + Thread_stack_overflow_flags_offset = 0x370; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x358; + 0x378; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x31c; + Thread_suspend_state_await_entry_point_offset = 0x33c; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x320; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x340; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x318; + Thread_suspend_state_init_async_entry_point_offset = 0x338; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x324; + Thread_suspend_state_return_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x328; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x32c; + Thread_suspend_state_init_async_star_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x330; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x334; + Thread_suspend_state_return_async_star_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x338; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x33c; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x340; + Thread_suspend_state_handle_exception_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x354; + Thread_top_exit_frame_info_offset = 0x374; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x370; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x368; + Thread_unboxed_runtime_arg_offset = 0x390; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x388; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3a8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3b0; + 0x3c8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x3d0; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3b8; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3d8; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -2050,11 +2064,12 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, -1, -1, -1, 0x314}; + 0x324, 0x328, 0x32c, 0x330, -1, -1, -1, 0x334}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x78; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -2467,219 +2482,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x760; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x768; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x7a0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x7a8; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7e0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d8; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x818; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x7a8; + Thread_double_truncate_round_supported_offset = 0x7e8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7e0; + Thread_service_extension_stream_offset = 0x820; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x788; + 0x7c8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x770; + 0x7b0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x798; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x700; + 0x7d8; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x740; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x708; + 0x748; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x730; + Thread_old_marking_stack_block_offset = 0x770; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x738; + Thread_new_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x778; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7b8; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x780; + Thread_saved_shadow_call_stack_offset = 0x7c0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x718; + Thread_stack_overflow_flags_offset = 0x758; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x728; + 0x768; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6b0; + Thread_suspend_state_await_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x6a8; + Thread_suspend_state_init_async_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6c0; + Thread_suspend_state_return_async_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; + Thread_suspend_state_init_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x730; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x720; + Thread_top_exit_frame_info_offset = 0x760; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x750; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x748; + Thread_unboxed_runtime_arg_offset = 0x790; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x788; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7b0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7b8; + 0x7f0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7f8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c0; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x800; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -2768,14 +2787,15 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, - 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, -1, - -1, -1, -1, 0x680, 0x688, -1, -1, 0x690, - 0x698, 0x6a0, -1, -1, -1, -1, -1, -1}; + 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, + 0x688, 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, -1, + -1, -1, -1, 0x6c0, 0x6c8, -1, -1, 0x6d0, + 0x6d8, 0x6e0, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc8; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -3186,220 +3206,224 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x24; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d8; + Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x720; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x728; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x200; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x140; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x230; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x148; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x760; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x768; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x150; + Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x148; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x238; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x150; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7a0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x158; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x208; + Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xc0; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x798; + Thread_call_to_runtime_stub_offset = 0xc8; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d8; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x768; + Thread_double_truncate_round_supported_offset = 0x7a8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7a0; + Thread_service_extension_stream_offset = 0x7e0; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x258; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a8; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x260; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1b0; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x268; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a8; + Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d8; + Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x748; + 0x788; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1e0; + Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1f0; + Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x268; + Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c8; + Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2c0; + Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b8; + 0x2c8; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2d0; + Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x730; + 0x770; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x758; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6c0; + 0x798; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x700; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x6f0; + Thread_old_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x6f8; + Thread_new_marking_stack_block_offset = 0x738; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x248; + Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x250; + Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x188; + Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x160; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x168; + Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x170; + Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x160; + 0x168; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x298; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x738; + Thread_predefined_symbols_address_offset = 0x2a8; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x778; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x740; + Thread_saved_shadow_call_stack_offset = 0x780; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x750; + 0x790; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c8; + Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x278; + Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x6d0; + 0x710; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x6d8; + Thread_stack_overflow_flags_offset = 0x718; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x6e8; + 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x670; + Thread_suspend_state_await_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x678; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x668; + Thread_suspend_state_init_async_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x680; + Thread_suspend_state_return_async_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x688; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x690; + Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x698; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6a0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6b0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6b8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x6e0; + Thread_top_exit_frame_info_offset = 0x720; static constexpr dart::compiler::target::word Thread_top_offset = 0x50; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x710; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x708; + Thread_unboxed_runtime_arg_offset = 0x750; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x748; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f8; + Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x770; -static constexpr dart::compiler::target::word Thread_random_offset = 0x778; + 0x7b0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7b8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x270; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x780; + Thread_jump_to_frame_entry_point_offset = 0x278; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -3486,12 +3510,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, -1, -1, 0x630, 0x638, - 0x640, 0x648, 0x650, -1, 0x658, 0x660, -1, -1}; + 0x650, 0x658, 0x660, 0x668, -1, -1, 0x670, 0x678, + 0x680, 0x688, 0x690, -1, 0x698, 0x6a0, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x10; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x80; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x20; @@ -3902,220 +3927,224 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x24; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d8; + Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x768; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x770; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x200; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x140; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x230; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x148; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x7a8; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x7b0; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x150; + Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x148; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x238; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x150; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7e8; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x158; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x208; + Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xc0; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7e0; + Thread_call_to_runtime_stub_offset = 0xc8; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x820; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x7b0; + Thread_double_truncate_round_supported_offset = 0x7f0; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7e8; + Thread_service_extension_stream_offset = 0x828; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x258; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a8; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x260; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1b0; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x268; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a8; + Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d8; + Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1e0; + Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1f0; + Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x268; + Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c8; + Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2c0; + Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b8; + 0x2c8; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2d0; + Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x778; + 0x7b8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x7a0; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x708; + 0x7e0; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x748; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x738; + Thread_old_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x740; + Thread_new_marking_stack_block_offset = 0x780; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x248; + Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x250; + Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x188; + Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x160; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x168; + Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x170; + Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x160; + 0x168; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x298; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x780; + Thread_predefined_symbols_address_offset = 0x2a8; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7c0; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x788; + Thread_saved_shadow_call_stack_offset = 0x7c8; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x798; + 0x7d8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c8; + Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x278; + Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x718; + 0x758; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x720; + Thread_stack_overflow_flags_offset = 0x760; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x730; + 0x770; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6b8; + Thread_suspend_state_await_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6c0; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x6b0; + Thread_suspend_state_init_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6c8; + Thread_suspend_state_return_async_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6d0; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6d8; + Thread_suspend_state_init_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6e0; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6e8; + Thread_suspend_state_return_async_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6f0; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x730; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f8; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x700; + Thread_suspend_state_handle_exception_entry_point_offset = 0x740; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x728; + Thread_top_exit_frame_info_offset = 0x768; static constexpr dart::compiler::target::word Thread_top_offset = 0x50; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x758; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x750; + Thread_unboxed_runtime_arg_offset = 0x798; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x790; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f8; + Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7b8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7c0; + 0x7f8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x800; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x270; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c8; + Thread_jump_to_frame_entry_point_offset = 0x278; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x808; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -4202,14 +4231,15 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, 0x648, - 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, -1, - -1, -1, -1, 0x688, 0x690, -1, -1, 0x698, - 0x6a0, 0x6a8, -1, -1, -1, -1, -1, -1}; + 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, 0x688, + 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, 0x6c0, -1, + -1, -1, -1, 0x6c8, 0x6d0, -1, -1, 0x6d8, + 0x6e0, 0x6e8, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x10; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x80; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x20; @@ -4618,219 +4648,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x3b0; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x3b4; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3d0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3d4; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3f0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3f4; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x414; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3d4; + Thread_double_truncate_round_supported_offset = 0x3f4; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3f8; + Thread_service_extension_stream_offset = 0x418; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x3c4; + 0x3e4; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x3b8; + 0x3d8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x3cc; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x378; + 0x3ec; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x398; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x37c; + 0x39c; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x390; + Thread_old_marking_stack_block_offset = 0x3b0; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x394; + Thread_new_marking_stack_block_offset = 0x3b4; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3bc; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3dc; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x3c0; + Thread_saved_shadow_call_stack_offset = 0x3e0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x3c8; + 0x3e8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x380; + 0x3a0; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x384; + Thread_stack_overflow_flags_offset = 0x3a4; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x38c; + 0x3ac; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x350; + Thread_suspend_state_await_entry_point_offset = 0x370; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x354; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x374; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x34c; + Thread_suspend_state_init_async_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x358; + Thread_suspend_state_return_async_entry_point_offset = 0x378; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x35c; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x360; + Thread_suspend_state_init_async_star_entry_point_offset = 0x380; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x364; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x384; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x368; + Thread_suspend_state_return_async_star_entry_point_offset = 0x388; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x36c; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x38c; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x370; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x390; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x374; + Thread_suspend_state_handle_exception_entry_point_offset = 0x394; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x388; + Thread_top_exit_frame_info_offset = 0x3a8; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x3a0; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x39c; + Thread_unboxed_runtime_arg_offset = 0x3c0; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x3bc; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3d8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3e0; + 0x3f8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x400; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3e8; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x408; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -4915,13 +4949,14 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x304, 0x308, 0x30c, -1, -1, 0x310, - 0x314, 0x318, -1, -1, -1, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, - 0x334, 0x338, -1, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348}; + -1, -1, -1, -1, -1, 0x324, 0x328, 0x32c, -1, -1, 0x330, + 0x334, 0x338, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348, 0x34c, 0x350, + 0x354, 0x358, -1, -1, -1, -1, 0x35c, 0x360, 0x364, 0x368}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x78; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -5334,219 +5369,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x750; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x758; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x790; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x798; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7d0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7c8; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x808; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x798; + Thread_double_truncate_round_supported_offset = 0x7d8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7d0; + Thread_service_extension_stream_offset = 0x810; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x760; + 0x7a0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x788; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6f0; + 0x7c8; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x730; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x720; + Thread_old_marking_stack_block_offset = 0x760; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x728; + Thread_new_marking_stack_block_offset = 0x768; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x768; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7a8; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x770; + Thread_saved_shadow_call_stack_offset = 0x7b0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x700; + 0x740; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x708; + Thread_stack_overflow_flags_offset = 0x748; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x718; + 0x758; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6a0; + Thread_suspend_state_await_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6a8; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x698; + Thread_suspend_state_init_async_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6b0; + Thread_suspend_state_return_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6b8; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6c0; + Thread_suspend_state_init_async_star_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6c8; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6d0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6d8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6e0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6e8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x710; + Thread_top_exit_frame_info_offset = 0x750; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x740; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x738; + Thread_unboxed_runtime_arg_offset = 0x780; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x778; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7a0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7a8; + 0x7e0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7e8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7b0; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7f0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -5635,13 +5674,14 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x608, 0x610, 0x618, -1, -1, 0x620, - 0x628, 0x630, -1, -1, -1, 0x638, 0x640, 0x648, 0x650, 0x658, 0x660, - 0x668, 0x670, -1, -1, -1, -1, 0x678, 0x680, 0x688, 0x690}; + -1, -1, -1, -1, -1, 0x648, 0x650, 0x658, -1, -1, 0x660, + 0x668, 0x670, -1, -1, -1, 0x678, 0x680, 0x688, 0x690, 0x698, 0x6a0, + 0x6a8, 0x6b0, -1, -1, -1, -1, 0x6b8, 0x6c0, 0x6c8, 0x6d0}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc8; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -6042,219 +6082,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x388; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x38c; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3a8; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3ac; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3c8; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3cc; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3ec; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3ac; + Thread_double_truncate_round_supported_offset = 0x3cc; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3d0; + Thread_service_extension_stream_offset = 0x3f0; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x39c; + 0x3bc; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x390; + 0x3b0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x3a4; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x350; + 0x3c4; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x370; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x354; + 0x374; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x368; + Thread_old_marking_stack_block_offset = 0x388; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x36c; + Thread_new_marking_stack_block_offset = 0x38c; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x394; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3b4; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x398; + Thread_saved_shadow_call_stack_offset = 0x3b8; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x3a0; + 0x3c0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x358; + 0x378; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x35c; + Thread_stack_overflow_flags_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x364; + 0x384; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x328; + Thread_suspend_state_await_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x32c; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x324; + Thread_suspend_state_init_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x330; + Thread_suspend_state_return_async_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x334; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x338; + Thread_suspend_state_init_async_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x33c; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x340; + Thread_suspend_state_return_async_star_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x344; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x364; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x348; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x368; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x34c; + Thread_suspend_state_handle_exception_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x360; + Thread_top_exit_frame_info_offset = 0x380; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x378; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x374; + Thread_unboxed_runtime_arg_offset = 0x398; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x394; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3b0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3b8; + 0x3d0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x3d8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3c0; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3e0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -6339,12 +6383,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, 0x314, -1, 0x318, -1, - 0x31c, 0x320, -1, -1, -1, -1, -1, -1}; + 0x324, 0x328, 0x32c, 0x330, 0x334, -1, 0x338, -1, + 0x33c, 0x340, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x74; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -6749,219 +6794,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x718; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x720; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x758; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x760; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x798; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x790; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d0; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x760; + Thread_double_truncate_round_supported_offset = 0x7a0; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x798; + Thread_service_extension_stream_offset = 0x7d8; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x740; + 0x780; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x728; + 0x768; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x750; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6b8; + 0x790; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6f8; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6c0; + 0x700; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x6e8; + Thread_old_marking_stack_block_offset = 0x728; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x6f0; + Thread_new_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x730; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x770; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x738; + Thread_saved_shadow_call_stack_offset = 0x778; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x748; + 0x788; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x6d0; + Thread_stack_overflow_flags_offset = 0x710; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x6e0; + 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x668; + Thread_suspend_state_await_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x670; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x660; + Thread_suspend_state_init_async_entry_point_offset = 0x6a0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x678; + Thread_suspend_state_return_async_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x680; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x688; + Thread_suspend_state_init_async_star_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x690; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x698; + Thread_suspend_state_return_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a0; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6a8; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6b0; + Thread_suspend_state_handle_exception_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x6d8; + Thread_top_exit_frame_info_offset = 0x718; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x708; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x700; + Thread_unboxed_runtime_arg_offset = 0x748; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x740; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x768; -static constexpr dart::compiler::target::word Thread_random_offset = 0x770; + 0x7a8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7b0; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x778; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7b8; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -7050,12 +7099,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, -1, -1, 0x628, 0x630, - 0x638, 0x640, 0x648, -1, 0x650, 0x658, -1, -1}; + 0x648, 0x650, 0x658, 0x660, -1, -1, 0x668, 0x670, + 0x678, 0x680, 0x688, -1, 0x690, 0x698, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc0; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -7456,219 +7506,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x380; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x384; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3a0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3a4; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3c0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3c4; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3e4; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3a4; + Thread_double_truncate_round_supported_offset = 0x3c4; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3c8; + Thread_service_extension_stream_offset = 0x3e8; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x394; + 0x3b4; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x388; + 0x3a8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x39c; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x344; + 0x3bc; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x364; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x348; + 0x368; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x35c; + Thread_old_marking_stack_block_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x360; + Thread_new_marking_stack_block_offset = 0x380; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x38c; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3ac; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x390; + Thread_saved_shadow_call_stack_offset = 0x3b0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x398; + 0x3b8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x34c; + 0x36c; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x350; + Thread_stack_overflow_flags_offset = 0x370; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x358; + 0x378; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x31c; + Thread_suspend_state_await_entry_point_offset = 0x33c; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x320; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x340; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x318; + Thread_suspend_state_init_async_entry_point_offset = 0x338; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x324; + Thread_suspend_state_return_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x328; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x32c; + Thread_suspend_state_init_async_star_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x330; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x334; + Thread_suspend_state_return_async_star_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x338; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x33c; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x340; + Thread_suspend_state_handle_exception_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x354; + Thread_top_exit_frame_info_offset = 0x374; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x370; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x368; + Thread_unboxed_runtime_arg_offset = 0x390; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x388; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3a8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3b0; + 0x3c8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x3d0; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3b8; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3d8; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -7753,11 +7807,12 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, -1, -1, -1, 0x314}; + 0x324, 0x328, 0x32c, 0x330, -1, -1, -1, 0x334}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x74; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -8162,219 +8217,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x760; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x768; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x7a0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x7a8; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7e0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d8; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x818; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x7a8; + Thread_double_truncate_round_supported_offset = 0x7e8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7e0; + Thread_service_extension_stream_offset = 0x820; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x788; + 0x7c8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x770; + 0x7b0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x798; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x700; + 0x7d8; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x740; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x708; + 0x748; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x730; + Thread_old_marking_stack_block_offset = 0x770; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x738; + Thread_new_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x778; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7b8; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x780; + Thread_saved_shadow_call_stack_offset = 0x7c0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x718; + Thread_stack_overflow_flags_offset = 0x758; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x728; + 0x768; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6b0; + Thread_suspend_state_await_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x6a8; + Thread_suspend_state_init_async_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6c0; + Thread_suspend_state_return_async_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; + Thread_suspend_state_init_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x730; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x720; + Thread_top_exit_frame_info_offset = 0x760; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x750; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x748; + Thread_unboxed_runtime_arg_offset = 0x790; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x788; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7b0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7b8; + 0x7f0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7f8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c0; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x800; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -8463,14 +8522,15 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, - 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, -1, - -1, -1, -1, 0x680, 0x688, -1, -1, 0x690, - 0x698, 0x6a0, -1, -1, -1, -1, -1, -1}; + 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, + 0x688, 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, -1, + -1, -1, -1, 0x6c0, 0x6c8, -1, -1, 0x6d0, + 0x6d8, 0x6e0, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc0; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -8873,220 +8933,224 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x24; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d8; + Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x720; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x728; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x200; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x140; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x230; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x148; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x760; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x768; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x150; + Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x148; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x238; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x150; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7a0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x158; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x208; + Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xc0; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x798; + Thread_call_to_runtime_stub_offset = 0xc8; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7d8; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x768; + Thread_double_truncate_round_supported_offset = 0x7a8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7a0; + Thread_service_extension_stream_offset = 0x7e0; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x258; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a8; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x260; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1b0; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x268; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a8; + Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d8; + Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x748; + 0x788; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1e0; + Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1f0; + Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x268; + Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c8; + Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2c0; + Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b8; + 0x2c8; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2d0; + Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x730; + 0x770; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x758; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6c0; + 0x798; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x700; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x6f0; + Thread_old_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x6f8; + Thread_new_marking_stack_block_offset = 0x738; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x248; + Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x250; + Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x188; + Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x160; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x168; + Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x170; + Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x160; + 0x168; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x298; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x738; + Thread_predefined_symbols_address_offset = 0x2a8; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x778; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x740; + Thread_saved_shadow_call_stack_offset = 0x780; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x750; + 0x790; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c8; + Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x278; + Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x6d0; + 0x710; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x6d8; + Thread_stack_overflow_flags_offset = 0x718; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x6e8; + 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x670; + Thread_suspend_state_await_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x678; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x668; + Thread_suspend_state_init_async_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x680; + Thread_suspend_state_return_async_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x688; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x690; + Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x698; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6a0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6b0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6b8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x6e0; + Thread_top_exit_frame_info_offset = 0x720; static constexpr dart::compiler::target::word Thread_top_offset = 0x50; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x710; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x708; + Thread_unboxed_runtime_arg_offset = 0x750; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x748; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f8; + Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x770; -static constexpr dart::compiler::target::word Thread_random_offset = 0x778; + 0x7b0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7b8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x270; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x780; + Thread_jump_to_frame_entry_point_offset = 0x278; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -9173,12 +9237,13 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, -1, -1, 0x630, 0x638, - 0x640, 0x648, 0x650, -1, 0x658, 0x660, -1, -1}; + 0x650, 0x658, 0x660, 0x668, -1, -1, 0x670, 0x678, + 0x680, 0x688, 0x690, -1, 0x698, 0x6a0, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x10; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x78; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x20; @@ -9581,220 +9646,224 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x24; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d8; + Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x768; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x770; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x200; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x140; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x230; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x148; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x7a8; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x7b0; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x150; + Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x148; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x238; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x150; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7e8; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x158; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x208; + Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xc0; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7e0; + Thread_call_to_runtime_stub_offset = 0xc8; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x820; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x7b0; + Thread_double_truncate_round_supported_offset = 0x7f0; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7e8; + Thread_service_extension_stream_offset = 0x828; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x258; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a8; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x260; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1b0; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x268; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a8; + Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d8; + Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1e0; + Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1f0; + Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x268; + Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c8; + Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2c0; + Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b8; + 0x2c8; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2d0; + Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x778; + 0x7b8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x7a0; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x708; + 0x7e0; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x748; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x738; + Thread_old_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x740; + Thread_new_marking_stack_block_offset = 0x780; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x248; + Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x250; + Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x188; + Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x160; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x168; + Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x170; + Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x160; + 0x168; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x298; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x780; + Thread_predefined_symbols_address_offset = 0x2a8; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7c0; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x788; + Thread_saved_shadow_call_stack_offset = 0x7c8; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x798; + 0x7d8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c8; + Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x278; + Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x718; + 0x758; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x720; + Thread_stack_overflow_flags_offset = 0x760; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x730; + 0x770; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6b8; + Thread_suspend_state_await_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6c0; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x6b0; + Thread_suspend_state_init_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6c8; + Thread_suspend_state_return_async_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6d0; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6d8; + Thread_suspend_state_init_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6e0; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6e8; + Thread_suspend_state_return_async_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6f0; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x730; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6f8; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x700; + Thread_suspend_state_handle_exception_entry_point_offset = 0x740; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x728; + Thread_top_exit_frame_info_offset = 0x768; static constexpr dart::compiler::target::word Thread_top_offset = 0x50; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x758; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x750; + Thread_unboxed_runtime_arg_offset = 0x798; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x790; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f8; + Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7b8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7c0; + 0x7f8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x800; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x270; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7c8; + Thread_jump_to_frame_entry_point_offset = 0x278; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x808; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -9881,14 +9950,15 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, 0x648, - 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, -1, - -1, -1, -1, 0x688, 0x690, -1, -1, 0x698, - 0x6a0, 0x6a8, -1, -1, -1, -1, -1, -1}; + 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, 0x688, + 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, 0x6c0, -1, + -1, -1, -1, 0x6c8, 0x6d0, -1, -1, 0x6d8, + 0x6e0, 0x6e8, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x10; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x78; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x20; @@ -10289,219 +10359,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0xc; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x14; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x168; + Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x3b0; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x3b4; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0xfc; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x10c; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x98; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x110; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x9c; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x114; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0xa0; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x3d0; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x3d4; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0xa4; + Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x110; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x9c; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x114; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0xa0; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x118; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0xa4; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x3f0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0xa8; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x100; + Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0x5c; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x3f4; + Thread_call_to_runtime_stub_offset = 0x60; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x414; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x3d4; + Thread_double_truncate_round_supported_offset = 0x3f4; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x3f8; + Thread_service_extension_stream_offset = 0x418; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x128; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0xd0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x12c; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0xd4; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x130; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0xd8; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x154; + 0x15c; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x150; + Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0xe8; + Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x3c4; + 0x3e4; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0xec; + Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0xf4; + Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x130; + Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x160; + Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x15c; + Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x164; + Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x3b8; + 0x3d8; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x3cc; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x378; + 0x3ec; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x398; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x37c; + 0x39c; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0xd8; + Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0xe4; + Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x390; + Thread_old_marking_stack_block_offset = 0x3b0; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x394; + Thread_new_marking_stack_block_offset = 0x3b4; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x120; + Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x124; + Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0xc0; + Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x64; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0x68; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x60; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0x64; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xa8; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0xac; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0xb0; + Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0xb4; + Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0xac; + 0xb0; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x148; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3bc; + Thread_predefined_symbols_address_offset = 0x150; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x3dc; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x3c0; + Thread_saved_shadow_call_stack_offset = 0x3e0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x3c8; + 0x3e8; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0xe0; + Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x138; + Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x380; + 0x3a0; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x384; + Thread_stack_overflow_flags_offset = 0x3a4; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x118; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x11c; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x38c; + 0x3ac; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x350; + Thread_suspend_state_await_entry_point_offset = 0x370; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x354; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x374; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x34c; + Thread_suspend_state_init_async_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x358; + Thread_suspend_state_return_async_entry_point_offset = 0x378; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x35c; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x37c; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x360; + Thread_suspend_state_init_async_star_entry_point_offset = 0x380; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x364; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x384; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x368; + Thread_suspend_state_return_async_star_entry_point_offset = 0x388; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x36c; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x38c; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x370; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x390; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x374; + Thread_suspend_state_handle_exception_entry_point_offset = 0x394; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x388; + Thread_top_exit_frame_info_offset = 0x3a8; static constexpr dart::compiler::target::word Thread_top_offset = 0x24; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x3a0; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x39c; + Thread_unboxed_runtime_arg_offset = 0x3c0; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x3bc; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0xf8; + Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x3d8; -static constexpr dart::compiler::target::word Thread_random_offset = 0x3e0; + 0x3f8; +static constexpr dart::compiler::target::word Thread_random_offset = 0x400; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x134; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x3e8; + Thread_jump_to_frame_entry_point_offset = 0x138; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x408; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -10586,13 +10660,14 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x304, 0x308, 0x30c, -1, -1, 0x310, - 0x314, 0x318, -1, -1, -1, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, - 0x334, 0x338, -1, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348}; + -1, -1, -1, -1, -1, 0x324, 0x328, 0x32c, -1, -1, 0x330, + 0x334, 0x338, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348, 0x34c, 0x350, + 0x354, 0x358, -1, -1, -1, -1, 0x35c, 0x360, 0x364, 0x368}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word Array_header_size = 0xc; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0x74; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x1c; @@ -10997,219 +11072,223 @@ static constexpr dart::compiler::target::word SuspendState_pc_offset = 0x18; static constexpr dart::compiler::target::word SuspendState_then_callback_offset = 0x28; static constexpr dart::compiler::target::word - Thread_AllocateArray_entry_point_offset = 0x2d0; + Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word Thread_active_exception_offset = - 0x750; -static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = - 0x758; -static constexpr dart::compiler::target::word - Thread_array_write_barrier_entry_point_offset = 0x1f8; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; -static constexpr dart::compiler::target::word - Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; -static constexpr dart::compiler::target::word - Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; -static constexpr dart::compiler::target::word - Thread_allocate_object_entry_point_offset = 0x218; -static constexpr dart::compiler::target::word - Thread_allocate_object_stub_offset = 0x130; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_entry_point_offset = 0x220; -static constexpr dart::compiler::target::word - Thread_allocate_object_parameterized_stub_offset = 0x138; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_entry_point_offset = 0x228; -static constexpr dart::compiler::target::word - Thread_allocate_object_slow_stub_offset = 0x140; -static constexpr dart::compiler::target::word Thread_api_top_scope_offset = 0x790; +static constexpr dart::compiler::target::word Thread_active_stacktrace_offset = + 0x798; static constexpr dart::compiler::target::word - Thread_async_exception_handler_stub_offset = 0x148; + Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; +static constexpr dart::compiler::target::word + Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; +static constexpr dart::compiler::target::word + Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; +static constexpr dart::compiler::target::word + Thread_allocate_object_entry_point_offset = 0x220; +static constexpr dart::compiler::target::word + Thread_allocate_object_stub_offset = 0x138; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_entry_point_offset = 0x228; +static constexpr dart::compiler::target::word + Thread_allocate_object_parameterized_stub_offset = 0x140; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_entry_point_offset = 0x230; +static constexpr dart::compiler::target::word + Thread_allocate_object_slow_stub_offset = 0x148; +static constexpr dart::compiler::target::word Thread_api_top_scope_offset = + 0x7d0; +static constexpr dart::compiler::target::word + Thread_async_exception_handler_stub_offset = 0x150; +static constexpr dart::compiler::target::word + Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - Thread_call_to_runtime_entry_point_offset = 0x200; + Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - Thread_call_to_runtime_stub_offset = 0xb8; -static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x7c8; + Thread_call_to_runtime_stub_offset = 0xc0; +static constexpr dart::compiler::target::word Thread_dart_stream_offset = 0x808; static constexpr dart::compiler::target::word Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - Thread_double_truncate_round_supported_offset = 0x798; + Thread_double_truncate_round_supported_offset = 0x7d8; static constexpr dart::compiler::target::word - Thread_service_extension_stream_offset = 0x7d0; + Thread_service_extension_stream_offset = 0x810; static constexpr dart::compiler::target::word Thread_optimize_entry_offset = - 0x250; -static constexpr dart::compiler::target::word Thread_optimize_stub_offset = - 0x1a0; -static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = 0x258; -static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = +static constexpr dart::compiler::target::word Thread_optimize_stub_offset = 0x1a8; +static constexpr dart::compiler::target::word Thread_deoptimize_entry_offset = + 0x260; +static constexpr dart::compiler::target::word Thread_deoptimize_stub_offset = + 0x1b0; static constexpr dart::compiler::target::word Thread_double_abs_address_offset = - 0x2a8; + 0x2b8; static constexpr dart::compiler::target::word - Thread_double_negate_address_offset = 0x2a0; + Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - Thread_enter_safepoint_stub_offset = 0x1d0; + Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word Thread_execution_state_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word - Thread_exit_safepoint_stub_offset = 0x1d8; + Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_stub_offset = 0x1e8; + Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - Thread_call_native_through_safepoint_entry_point_offset = 0x260; + Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - Thread_float_absolute_address_offset = 0x2c0; + Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - Thread_float_negate_address_offset = 0x2b8; + Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word Thread_float_not_address_offset = - 0x2b0; + 0x2c0; static constexpr dart::compiler::target::word - Thread_float_zerow_address_offset = 0x2c8; + Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word Thread_global_object_pool_offset = - 0x760; + 0x7a0; +static constexpr dart::compiler::target::word + Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word Thread_exit_through_ffi_offset = - 0x788; -static constexpr dart::compiler::target::word Thread_isolate_offset = 0x6f0; + 0x7c8; +static constexpr dart::compiler::target::word Thread_isolate_offset = 0x730; static constexpr dart::compiler::target::word Thread_isolate_group_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - Thread_old_marking_stack_block_offset = 0x720; + Thread_old_marking_stack_block_offset = 0x760; static constexpr dart::compiler::target::word - Thread_new_marking_stack_block_offset = 0x728; + Thread_new_marking_stack_block_offset = 0x768; static constexpr dart::compiler::target::word - Thread_megamorphic_call_checked_entry_offset = 0x240; + Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_entry_offset = 0x248; + Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - Thread_switchable_call_miss_stub_offset = 0x180; + Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xc8; + Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = 0xd0; static constexpr dart::compiler::target::word - Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc0; + Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = 0xc8; static constexpr dart::compiler::target::word - Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; -static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x150; + Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; +static constexpr dart::compiler::target::word Thread_resume_stub_offset = 0x158; static constexpr dart::compiler::target::word - Thread_return_async_not_future_stub_offset = 0x160; + Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - Thread_return_async_star_stub_offset = 0x168; + Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word Thread_return_async_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - Thread_predefined_symbols_address_offset = 0x290; -static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x768; + Thread_predefined_symbols_address_offset = 0x2a0; +static constexpr dart::compiler::target::word Thread_resume_pc_offset = 0x7a8; static constexpr dart::compiler::target::word - Thread_saved_shadow_call_stack_offset = 0x770; + Thread_saved_shadow_call_stack_offset = 0x7b0; static constexpr dart::compiler::target::word Thread_safepoint_state_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - Thread_slow_type_test_stub_offset = 0x1c0; + Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - Thread_slow_type_test_entry_point_offset = 0x270; + Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word Thread_saved_stack_limit_offset = - 0x700; + 0x740; static constexpr dart::compiler::target::word - Thread_stack_overflow_flags_offset = 0x708; + Thread_stack_overflow_flags_offset = 0x748; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x230; + Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word Thread_store_buffer_block_offset = - 0x718; + 0x758; static constexpr dart::compiler::target::word - Thread_suspend_state_await_entry_point_offset = 0x6a0; + Thread_suspend_state_await_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6a8; + Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_entry_point_offset = 0x698; + Thread_suspend_state_init_async_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_entry_point_offset = 0x6b0; + Thread_suspend_state_return_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6b8; + Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - Thread_suspend_state_init_async_star_entry_point_offset = 0x6c0; + Thread_suspend_state_init_async_star_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - Thread_suspend_state_yield_async_star_entry_point_offset = 0x6c8; + Thread_suspend_state_yield_async_star_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - Thread_suspend_state_return_async_star_entry_point_offset = 0x6d0; + Thread_suspend_state_return_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - Thread_suspend_state_init_sync_star_entry_point_offset = 0x6d8; + Thread_suspend_state_init_sync_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x6e0; + Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - Thread_suspend_state_handle_exception_entry_point_offset = 0x6e8; + Thread_suspend_state_handle_exception_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - Thread_top_exit_frame_info_offset = 0x710; + Thread_top_exit_frame_info_offset = 0x750; static constexpr dart::compiler::target::word Thread_top_offset = 0x48; static constexpr dart::compiler::target::word Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - Thread_unboxed_runtime_arg_offset = 0x740; -static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x738; + Thread_unboxed_runtime_arg_offset = 0x780; +static constexpr dart::compiler::target::word Thread_vm_tag_offset = 0x778; static constexpr dart::compiler::target::word - Thread_write_barrier_entry_point_offset = 0x1f0; + Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word Thread_next_task_id_offset = - 0x7a0; -static constexpr dart::compiler::target::word Thread_random_offset = 0x7a8; + 0x7e0; +static constexpr dart::compiler::target::word Thread_random_offset = 0x7e8; static constexpr dart::compiler::target::word - Thread_jump_to_frame_entry_point_offset = 0x268; -static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7b0; + Thread_jump_to_frame_entry_point_offset = 0x270; +static constexpr dart::compiler::target::word Thread_tsan_utils_offset = 0x7f0; static constexpr dart::compiler::target::word TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word TsanUtils_setjmp_buffer_offset = @@ -11298,13 +11377,14 @@ static constexpr dart::compiler::target::word Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x608, 0x610, 0x618, -1, -1, 0x620, - 0x628, 0x630, -1, -1, -1, 0x638, 0x640, 0x648, 0x650, 0x658, 0x660, - 0x668, 0x670, -1, -1, -1, -1, 0x678, 0x680, 0x688, 0x690}; + -1, -1, -1, -1, -1, 0x648, 0x650, 0x658, -1, -1, 0x660, + 0x668, 0x670, -1, -1, -1, 0x678, 0x680, 0x688, 0x690, 0x698, 0x6a0, + 0x6a8, 0x6b0, -1, -1, -1, -1, 0x6b8, 0x6c0, 0x6c8, 0x6d0}; static constexpr dart::compiler::target::word AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word Array_header_size = 0x18; static constexpr dart::compiler::target::word Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word Class_InstanceSize = 0xc0; static constexpr dart::compiler::target::word Closure_InstanceSize = 0x38; @@ -11745,232 +11825,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x8; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x168; + AOT_Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x388; + AOT_Thread_active_exception_offset = 0x3a8; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x38c; + AOT_Thread_active_stacktrace_offset = 0x3ac; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0xfc; + AOT_Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x10c; + AOT_Thread_allocate_object_entry_point_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x98; + AOT_Thread_allocate_object_stub_offset = 0x9c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x110; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x114; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x9c; + AOT_Thread_allocate_object_parameterized_stub_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x114; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0xa0; + AOT_Thread_allocate_object_slow_stub_offset = 0xa4; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x3a8; + 0x3c8; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0xa4; + AOT_Thread_async_exception_handler_stub_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x100; + AOT_Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0x5c; + AOT_Thread_call_to_runtime_stub_offset = 0x60; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x3cc; + 0x3ec; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x3ac; + AOT_Thread_double_truncate_round_supported_offset = 0x3cc; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x3d0; + AOT_Thread_service_extension_stream_offset = 0x3f0; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x128; + 0x12c; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0xd0; + 0xd4; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x12c; + AOT_Thread_deoptimize_entry_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0xd4; + AOT_Thread_deoptimize_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x154; + AOT_Thread_double_abs_address_offset = 0x15c; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x150; + AOT_Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0xe8; + AOT_Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x39c; + AOT_Thread_execution_state_offset = 0x3bc; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0xec; + AOT_Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0xf4; + AOT_Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x130; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x160; + AOT_Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x15c; + AOT_Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x158; + AOT_Thread_float_not_address_offset = 0x160; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x164; + AOT_Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x390; + AOT_Thread_global_object_pool_offset = 0x3b0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x3a4; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x350; + AOT_Thread_exit_through_ffi_offset = 0x3c4; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x370; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x354; + 0x374; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0xd8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe4; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x368; + AOT_Thread_old_marking_stack_block_offset = 0x388; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x36c; + AOT_Thread_new_marking_stack_block_offset = 0x38c; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x120; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x124; + AOT_Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0xc0; + AOT_Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0x64; + 0x68; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0x60; + 0x64; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0xa8; + 0xac; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0xb0; + AOT_Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0xb4; + AOT_Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0xac; + AOT_Thread_return_async_stub_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x148; + AOT_Thread_predefined_symbols_address_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x394; + 0x3b4; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x398; + AOT_Thread_saved_shadow_call_stack_offset = 0x3b8; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x3a0; + AOT_Thread_safepoint_state_offset = 0x3c0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0xe0; + AOT_Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x138; + AOT_Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x358; + AOT_Thread_saved_stack_limit_offset = 0x378; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x35c; + AOT_Thread_stack_overflow_flags_offset = 0x37c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x118; + 0x11c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x364; + AOT_Thread_store_buffer_block_offset = 0x384; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x328; + AOT_Thread_suspend_state_await_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x32c; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x324; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x330; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x334; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x338; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x33c; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x340; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x344; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x364; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x348; + 0x368; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x34c; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x360; + AOT_Thread_top_exit_frame_info_offset = 0x380; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x24; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x378; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x374; + AOT_Thread_unboxed_runtime_arg_offset = 0x398; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x394; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0xf8; + AOT_Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x3b0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3b8; + 0x3d0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3d8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x134; + AOT_Thread_jump_to_frame_entry_point_offset = 0x138; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x3c0; + 0x3e0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -12070,13 +12154,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, 0x314, -1, 0x318, -1, - 0x31c, 0x320, -1, -1, -1, -1, -1, -1}; + 0x324, 0x328, 0x32c, 0x330, 0x334, -1, 0x338, -1, + 0x33c, 0x340, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word AOT_Array_header_size = 0xc; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x60; @@ -12538,232 +12623,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x718; + AOT_Thread_active_exception_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x720; + AOT_Thread_active_stacktrace_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x758; + 0x798; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x760; + AOT_Thread_double_truncate_round_supported_offset = 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x798; + AOT_Thread_service_extension_stream_offset = 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x740; + AOT_Thread_execution_state_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x728; + AOT_Thread_global_object_pool_offset = 0x768; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x750; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6b8; + AOT_Thread_exit_through_ffi_offset = 0x790; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6f8; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6c0; + 0x700; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x6e8; + AOT_Thread_old_marking_stack_block_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x6f0; + AOT_Thread_new_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x730; + 0x770; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x738; + AOT_Thread_saved_shadow_call_stack_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x748; + AOT_Thread_safepoint_state_offset = 0x788; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x6c8; + AOT_Thread_saved_stack_limit_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x6d0; + AOT_Thread_stack_overflow_flags_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x6e0; + AOT_Thread_store_buffer_block_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x668; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x670; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x660; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x678; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x680; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x688; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x690; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x698; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6a8; + 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x6d8; + AOT_Thread_top_exit_frame_info_offset = 0x718; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x708; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x700; + AOT_Thread_unboxed_runtime_arg_offset = 0x748; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x768; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x770; + 0x7a8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -12863,13 +12952,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, -1, -1, 0x628, 0x630, - 0x638, 0x640, 0x648, -1, 0x650, 0x658, -1, -1}; + 0x648, 0x650, 0x658, 0x660, -1, -1, 0x668, 0x670, + 0x678, 0x680, 0x688, -1, 0x690, 0x698, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0xa8; @@ -13338,232 +13428,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x760; + AOT_Thread_active_exception_offset = 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x768; + AOT_Thread_active_stacktrace_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x7a0; + 0x7e0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7d8; + 0x818; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x7a8; + AOT_Thread_double_truncate_round_supported_offset = 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7e0; + AOT_Thread_service_extension_stream_offset = 0x820; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x788; + AOT_Thread_execution_state_offset = 0x7c8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x770; + AOT_Thread_global_object_pool_offset = 0x7b0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x798; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x700; + AOT_Thread_exit_through_ffi_offset = 0x7d8; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x740; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x708; + 0x748; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x730; + AOT_Thread_old_marking_stack_block_offset = 0x770; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x738; + AOT_Thread_new_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x780; + AOT_Thread_saved_shadow_call_stack_offset = 0x7c0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x790; + AOT_Thread_safepoint_state_offset = 0x7d0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x710; + AOT_Thread_saved_stack_limit_offset = 0x750; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x718; + AOT_Thread_stack_overflow_flags_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x728; + AOT_Thread_store_buffer_block_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6f0; + 0x730; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x720; + AOT_Thread_top_exit_frame_info_offset = 0x760; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x750; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x748; + AOT_Thread_unboxed_runtime_arg_offset = 0x790; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x788; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7b0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b8; + 0x7f0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7f8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7c0; + 0x800; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -13663,15 +13757,16 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, - 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, -1, - -1, -1, -1, 0x680, 0x688, -1, -1, 0x690, - 0x698, 0x6a0, -1, -1, -1, -1, -1, -1}; + 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, + 0x688, 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, -1, + -1, -1, -1, 0x6c0, 0x6c8, -1, -1, 0x6d0, + 0x6d8, 0x6e0, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0xa8; @@ -14134,234 +14229,238 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d8; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x720; + AOT_Thread_active_exception_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x728; + AOT_Thread_active_stacktrace_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x200; + AOT_Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x220; + AOT_Thread_allocate_object_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x138; + AOT_Thread_allocate_object_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x148; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x148; + AOT_Thread_allocate_object_slow_stub_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x760; + 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x150; + AOT_Thread_async_exception_handler_stub_offset = 0x158; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x208; + AOT_Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xc0; + AOT_Thread_call_to_runtime_stub_offset = 0xc8; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x798; + 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x768; + AOT_Thread_double_truncate_round_supported_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7a0; + AOT_Thread_service_extension_stream_offset = 0x7e0; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x258; + 0x260; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a8; + 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x260; + AOT_Thread_deoptimize_entry_offset = 0x268; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1b0; + AOT_Thread_deoptimize_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2b0; + AOT_Thread_double_abs_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a8; + AOT_Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d8; + AOT_Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x748; + AOT_Thread_execution_state_offset = 0x788; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c8; + AOT_Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2c0; + AOT_Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b8; + AOT_Thread_float_not_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2d0; + AOT_Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x730; + AOT_Thread_global_object_pool_offset = 0x770; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x758; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6c0; + AOT_Thread_exit_through_ffi_offset = 0x798; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x700; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x6f0; + AOT_Thread_old_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x6f8; + AOT_Thread_new_marking_stack_block_offset = 0x738; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x250; + AOT_Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x188; + AOT_Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xd0; + 0xd8; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x168; + AOT_Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x170; + AOT_Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x160; + AOT_Thread_return_async_stub_offset = 0x168; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x298; + AOT_Thread_predefined_symbols_address_offset = 0x2a8; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x738; + 0x778; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x740; + AOT_Thread_saved_shadow_call_stack_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x750; + AOT_Thread_safepoint_state_offset = 0x790; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c8; + AOT_Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x278; + AOT_Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x6d0; + AOT_Thread_saved_stack_limit_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x6d8; + AOT_Thread_stack_overflow_flags_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x238; + 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x6e8; + AOT_Thread_store_buffer_block_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x670; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x678; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x668; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x680; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x688; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x690; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x698; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6b0; + 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x6e0; + AOT_Thread_top_exit_frame_info_offset = 0x720; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x50; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x710; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x708; + AOT_Thread_unboxed_runtime_arg_offset = 0x750; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x748; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x770; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x778; + 0x7b0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x270; + AOT_Thread_jump_to_frame_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -14461,13 +14560,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, -1, -1, 0x630, 0x638, - 0x640, 0x648, 0x650, -1, 0x658, 0x660, -1, -1}; + 0x650, 0x658, 0x660, 0x668, -1, -1, 0x670, 0x678, + 0x680, 0x688, 0x690, -1, 0x698, 0x6a0, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x10; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x68; @@ -14930,234 +15030,238 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d8; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x768; + AOT_Thread_active_exception_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x770; + AOT_Thread_active_stacktrace_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x200; + AOT_Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x220; + AOT_Thread_allocate_object_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x138; + AOT_Thread_allocate_object_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x148; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x148; + AOT_Thread_allocate_object_slow_stub_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x7a8; + 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x150; + AOT_Thread_async_exception_handler_stub_offset = 0x158; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x208; + AOT_Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xc0; + AOT_Thread_call_to_runtime_stub_offset = 0xc8; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7e0; + 0x820; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x7b0; + AOT_Thread_double_truncate_round_supported_offset = 0x7f0; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7e8; + AOT_Thread_service_extension_stream_offset = 0x828; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x258; + 0x260; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a8; + 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x260; + AOT_Thread_deoptimize_entry_offset = 0x268; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1b0; + AOT_Thread_deoptimize_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2b0; + AOT_Thread_double_abs_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a8; + AOT_Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d8; + AOT_Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x790; + AOT_Thread_execution_state_offset = 0x7d0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c8; + AOT_Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2c0; + AOT_Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b8; + AOT_Thread_float_not_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2d0; + AOT_Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x778; + AOT_Thread_global_object_pool_offset = 0x7b8; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x7a0; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x708; + AOT_Thread_exit_through_ffi_offset = 0x7e0; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x748; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x738; + AOT_Thread_old_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x740; + AOT_Thread_new_marking_stack_block_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x250; + AOT_Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x188; + AOT_Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xd0; + 0xd8; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x168; + AOT_Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x170; + AOT_Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x160; + AOT_Thread_return_async_stub_offset = 0x168; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x298; + AOT_Thread_predefined_symbols_address_offset = 0x2a8; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x788; + AOT_Thread_saved_shadow_call_stack_offset = 0x7c8; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x798; + AOT_Thread_safepoint_state_offset = 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c8; + AOT_Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x278; + AOT_Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x718; + AOT_Thread_saved_stack_limit_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x720; + AOT_Thread_stack_overflow_flags_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x238; + 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x730; + AOT_Thread_store_buffer_block_offset = 0x770; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6e0; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6f0; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x730; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x700; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x728; + AOT_Thread_top_exit_frame_info_offset = 0x768; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x50; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x758; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x750; + AOT_Thread_unboxed_runtime_arg_offset = 0x798; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x790; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7b8; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7c0; + 0x7f8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x800; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x270; + AOT_Thread_jump_to_frame_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7c8; + 0x808; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -15257,15 +15361,16 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, 0x648, - 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, -1, - -1, -1, -1, 0x688, 0x690, -1, -1, 0x698, - 0x6a0, 0x6a8, -1, -1, -1, -1, -1, -1}; + 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, 0x688, + 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, 0x6c0, -1, + -1, -1, -1, 0x6c8, 0x6d0, -1, -1, 0x6d8, + 0x6e0, 0x6e8, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x10; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x68; @@ -15728,232 +15833,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x8; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x168; + AOT_Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x3b0; + AOT_Thread_active_exception_offset = 0x3d0; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x3b4; + AOT_Thread_active_stacktrace_offset = 0x3d4; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0xfc; + AOT_Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x10c; + AOT_Thread_allocate_object_entry_point_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x98; + AOT_Thread_allocate_object_stub_offset = 0x9c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x110; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x114; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x9c; + AOT_Thread_allocate_object_parameterized_stub_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x114; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0xa0; + AOT_Thread_allocate_object_slow_stub_offset = 0xa4; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x3d0; + 0x3f0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0xa4; + AOT_Thread_async_exception_handler_stub_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x100; + AOT_Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0x5c; + AOT_Thread_call_to_runtime_stub_offset = 0x60; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x3f4; + 0x414; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x3d4; + AOT_Thread_double_truncate_round_supported_offset = 0x3f4; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x3f8; + AOT_Thread_service_extension_stream_offset = 0x418; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x128; + 0x12c; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0xd0; + 0xd4; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x12c; + AOT_Thread_deoptimize_entry_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0xd4; + AOT_Thread_deoptimize_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x154; + AOT_Thread_double_abs_address_offset = 0x15c; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x150; + AOT_Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0xe8; + AOT_Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x3c4; + AOT_Thread_execution_state_offset = 0x3e4; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0xec; + AOT_Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0xf4; + AOT_Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x130; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x160; + AOT_Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x15c; + AOT_Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x158; + AOT_Thread_float_not_address_offset = 0x160; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x164; + AOT_Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x3b8; + AOT_Thread_global_object_pool_offset = 0x3d8; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x3cc; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x378; + AOT_Thread_exit_through_ffi_offset = 0x3ec; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x398; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x37c; + 0x39c; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0xd8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe4; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x390; + AOT_Thread_old_marking_stack_block_offset = 0x3b0; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x394; + AOT_Thread_new_marking_stack_block_offset = 0x3b4; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x120; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x124; + AOT_Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0xc0; + AOT_Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0x64; + 0x68; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0x60; + 0x64; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0xa8; + 0xac; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0xb0; + AOT_Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0xb4; + AOT_Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0xac; + AOT_Thread_return_async_stub_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x148; + AOT_Thread_predefined_symbols_address_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x3bc; + 0x3dc; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x3c0; + AOT_Thread_saved_shadow_call_stack_offset = 0x3e0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x3c8; + AOT_Thread_safepoint_state_offset = 0x3e8; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0xe0; + AOT_Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x138; + AOT_Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x380; + AOT_Thread_saved_stack_limit_offset = 0x3a0; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x384; + AOT_Thread_stack_overflow_flags_offset = 0x3a4; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x118; + 0x11c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x38c; + AOT_Thread_store_buffer_block_offset = 0x3ac; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x350; + AOT_Thread_suspend_state_await_entry_point_offset = 0x370; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x354; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x374; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x34c; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x358; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x378; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x35c; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x37c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x360; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x380; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x364; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x384; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x368; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x388; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x36c; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x38c; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x370; + 0x390; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x374; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x394; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x388; + AOT_Thread_top_exit_frame_info_offset = 0x3a8; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x24; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x3a0; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x39c; + AOT_Thread_unboxed_runtime_arg_offset = 0x3c0; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x3bc; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0xf8; + AOT_Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x3d8; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3e0; + 0x3f8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x400; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x134; + AOT_Thread_jump_to_frame_entry_point_offset = 0x138; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x3e8; + 0x408; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -16053,14 +16162,15 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x304, 0x308, 0x30c, -1, -1, 0x310, - 0x314, 0x318, -1, -1, -1, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, - 0x334, 0x338, -1, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348}; + -1, -1, -1, -1, -1, 0x324, 0x328, 0x32c, -1, -1, 0x330, + 0x334, 0x338, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348, 0x34c, 0x350, + 0x354, 0x358, -1, -1, -1, -1, 0x35c, 0x360, 0x364, 0x368}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word AOT_Array_header_size = 0xc; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x60; @@ -16522,232 +16632,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x750; + AOT_Thread_active_exception_offset = 0x790; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x758; + AOT_Thread_active_stacktrace_offset = 0x798; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7c8; + 0x808; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x798; + AOT_Thread_double_truncate_round_supported_offset = 0x7d8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7d0; + AOT_Thread_service_extension_stream_offset = 0x810; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x778; + AOT_Thread_execution_state_offset = 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x760; + AOT_Thread_global_object_pool_offset = 0x7a0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x788; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6f0; + AOT_Thread_exit_through_ffi_offset = 0x7c8; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x730; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x720; + AOT_Thread_old_marking_stack_block_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x728; + AOT_Thread_new_marking_stack_block_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x768; + 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x770; + AOT_Thread_saved_shadow_call_stack_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x780; + AOT_Thread_safepoint_state_offset = 0x7c0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x700; + AOT_Thread_saved_stack_limit_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x708; + AOT_Thread_stack_overflow_flags_offset = 0x748; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x718; + AOT_Thread_store_buffer_block_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x698; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6e0; + 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x710; + AOT_Thread_top_exit_frame_info_offset = 0x750; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x740; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x738; + AOT_Thread_unboxed_runtime_arg_offset = 0x780; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7a0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7a8; + 0x7e0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7b0; + 0x7f0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -16847,14 +16961,15 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x608, 0x610, 0x618, -1, -1, 0x620, - 0x628, 0x630, -1, -1, -1, 0x638, 0x640, 0x648, 0x650, 0x658, 0x660, - 0x668, 0x670, -1, -1, -1, -1, 0x678, 0x680, 0x688, 0x690}; + -1, -1, -1, -1, -1, 0x648, 0x650, 0x658, -1, -1, 0x660, + 0x668, 0x670, -1, -1, -1, 0x678, 0x680, 0x688, 0x690, 0x698, 0x6a0, + 0x6a8, 0x6b0, -1, -1, -1, -1, 0x6b8, 0x6c0, 0x6c8, 0x6d0}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0xa8; @@ -17308,232 +17423,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x8; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x168; + AOT_Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x388; + AOT_Thread_active_exception_offset = 0x3a8; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x38c; + AOT_Thread_active_stacktrace_offset = 0x3ac; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0xfc; + AOT_Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x10c; + AOT_Thread_allocate_object_entry_point_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x98; + AOT_Thread_allocate_object_stub_offset = 0x9c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x110; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x114; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x9c; + AOT_Thread_allocate_object_parameterized_stub_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x114; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0xa0; + AOT_Thread_allocate_object_slow_stub_offset = 0xa4; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x3a8; + 0x3c8; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0xa4; + AOT_Thread_async_exception_handler_stub_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x100; + AOT_Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0x5c; + AOT_Thread_call_to_runtime_stub_offset = 0x60; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x3cc; + 0x3ec; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x3ac; + AOT_Thread_double_truncate_round_supported_offset = 0x3cc; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x3d0; + AOT_Thread_service_extension_stream_offset = 0x3f0; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x128; + 0x12c; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0xd0; + 0xd4; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x12c; + AOT_Thread_deoptimize_entry_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0xd4; + AOT_Thread_deoptimize_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x154; + AOT_Thread_double_abs_address_offset = 0x15c; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x150; + AOT_Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0xe8; + AOT_Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x39c; + AOT_Thread_execution_state_offset = 0x3bc; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0xec; + AOT_Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0xf4; + AOT_Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x130; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x160; + AOT_Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x15c; + AOT_Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x158; + AOT_Thread_float_not_address_offset = 0x160; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x164; + AOT_Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x390; + AOT_Thread_global_object_pool_offset = 0x3b0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x3a4; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x350; + AOT_Thread_exit_through_ffi_offset = 0x3c4; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x370; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x354; + 0x374; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0xd8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe4; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x368; + AOT_Thread_old_marking_stack_block_offset = 0x388; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x36c; + AOT_Thread_new_marking_stack_block_offset = 0x38c; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x120; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x124; + AOT_Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0xc0; + AOT_Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0x64; + 0x68; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0x60; + 0x64; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0xa8; + 0xac; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0xb0; + AOT_Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0xb4; + AOT_Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0xac; + AOT_Thread_return_async_stub_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x148; + AOT_Thread_predefined_symbols_address_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x394; + 0x3b4; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x398; + AOT_Thread_saved_shadow_call_stack_offset = 0x3b8; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x3a0; + AOT_Thread_safepoint_state_offset = 0x3c0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0xe0; + AOT_Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x138; + AOT_Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x358; + AOT_Thread_saved_stack_limit_offset = 0x378; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x35c; + AOT_Thread_stack_overflow_flags_offset = 0x37c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x118; + 0x11c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x364; + AOT_Thread_store_buffer_block_offset = 0x384; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x328; + AOT_Thread_suspend_state_await_entry_point_offset = 0x348; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x32c; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x34c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x324; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x344; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x330; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x350; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x334; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x354; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x338; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x358; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x33c; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x35c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x340; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x360; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x344; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x364; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x348; + 0x368; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x34c; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x360; + AOT_Thread_top_exit_frame_info_offset = 0x380; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x24; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x378; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x374; + AOT_Thread_unboxed_runtime_arg_offset = 0x398; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x394; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0xf8; + AOT_Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x3b0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3b8; + 0x3d0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3d8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x134; + AOT_Thread_jump_to_frame_entry_point_offset = 0x138; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x3c0; + 0x3e0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -17633,13 +17752,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x304, 0x308, 0x30c, 0x310, 0x314, -1, 0x318, -1, - 0x31c, 0x320, -1, -1, -1, -1, -1, -1}; + 0x324, 0x328, 0x32c, 0x330, 0x334, -1, 0x338, -1, + 0x33c, 0x340, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word AOT_Array_header_size = 0xc; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x54; @@ -18092,232 +18212,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x718; + AOT_Thread_active_exception_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x720; + AOT_Thread_active_stacktrace_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x758; + 0x798; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x760; + AOT_Thread_double_truncate_round_supported_offset = 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x798; + AOT_Thread_service_extension_stream_offset = 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x740; + AOT_Thread_execution_state_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x728; + AOT_Thread_global_object_pool_offset = 0x768; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x750; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6b8; + AOT_Thread_exit_through_ffi_offset = 0x790; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6f8; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6c0; + 0x700; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x6e8; + AOT_Thread_old_marking_stack_block_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x6f0; + AOT_Thread_new_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x730; + 0x770; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x738; + AOT_Thread_saved_shadow_call_stack_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x748; + AOT_Thread_safepoint_state_offset = 0x788; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x6c8; + AOT_Thread_saved_stack_limit_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x6d0; + AOT_Thread_stack_overflow_flags_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x6e0; + AOT_Thread_store_buffer_block_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x668; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x670; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x660; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x678; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x680; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x688; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x690; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x698; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6a8; + 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x6d8; + AOT_Thread_top_exit_frame_info_offset = 0x718; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x708; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x700; + AOT_Thread_unboxed_runtime_arg_offset = 0x748; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x768; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x770; + 0x7a8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -18417,13 +18541,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, -1, -1, 0x628, 0x630, - 0x638, 0x640, 0x648, -1, 0x650, 0x658, -1, -1}; + 0x648, 0x650, 0x658, 0x660, -1, -1, 0x668, 0x670, + 0x678, 0x680, 0x688, -1, 0x690, 0x698, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x90; @@ -18883,232 +19008,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x760; + AOT_Thread_active_exception_offset = 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x768; + AOT_Thread_active_stacktrace_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x7a0; + 0x7e0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7d8; + 0x818; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x7a8; + AOT_Thread_double_truncate_round_supported_offset = 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7e0; + AOT_Thread_service_extension_stream_offset = 0x820; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x788; + AOT_Thread_execution_state_offset = 0x7c8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x770; + AOT_Thread_global_object_pool_offset = 0x7b0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x798; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x700; + AOT_Thread_exit_through_ffi_offset = 0x7d8; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x740; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x708; + 0x748; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x730; + AOT_Thread_old_marking_stack_block_offset = 0x770; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x738; + AOT_Thread_new_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x778; + 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x780; + AOT_Thread_saved_shadow_call_stack_offset = 0x7c0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x790; + AOT_Thread_safepoint_state_offset = 0x7d0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x710; + AOT_Thread_saved_stack_limit_offset = 0x750; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x718; + AOT_Thread_stack_overflow_flags_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x728; + AOT_Thread_store_buffer_block_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6f0; + 0x730; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x738; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x720; + AOT_Thread_top_exit_frame_info_offset = 0x760; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x750; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x748; + AOT_Thread_unboxed_runtime_arg_offset = 0x790; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x788; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7b0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b8; + 0x7f0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7f8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7c0; + 0x800; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -19208,15 +19337,16 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x608, 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, - 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, -1, - -1, -1, -1, 0x680, 0x688, -1, -1, 0x690, - 0x698, 0x6a0, -1, -1, -1, -1, -1, -1}; + 0x648, 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, + 0x688, 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, -1, + -1, -1, -1, 0x6c0, 0x6c8, -1, -1, 0x6d0, + 0x6d8, 0x6e0, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x90; @@ -19670,234 +19800,238 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d8; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x720; + AOT_Thread_active_exception_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x728; + AOT_Thread_active_stacktrace_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x200; + AOT_Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x220; + AOT_Thread_allocate_object_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x138; + AOT_Thread_allocate_object_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x148; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x148; + AOT_Thread_allocate_object_slow_stub_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x760; + 0x7a0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x150; + AOT_Thread_async_exception_handler_stub_offset = 0x158; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x208; + AOT_Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xc0; + AOT_Thread_call_to_runtime_stub_offset = 0xc8; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x798; + 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x768; + AOT_Thread_double_truncate_round_supported_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7a0; + AOT_Thread_service_extension_stream_offset = 0x7e0; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x258; + 0x260; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a8; + 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x260; + AOT_Thread_deoptimize_entry_offset = 0x268; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1b0; + AOT_Thread_deoptimize_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2b0; + AOT_Thread_double_abs_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a8; + AOT_Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d8; + AOT_Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x748; + AOT_Thread_execution_state_offset = 0x788; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c8; + AOT_Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2c0; + AOT_Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b8; + AOT_Thread_float_not_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2d0; + AOT_Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x730; + AOT_Thread_global_object_pool_offset = 0x770; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x758; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6c0; + AOT_Thread_exit_through_ffi_offset = 0x798; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x700; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6c8; + 0x708; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x6f0; + AOT_Thread_old_marking_stack_block_offset = 0x730; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x6f8; + AOT_Thread_new_marking_stack_block_offset = 0x738; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x250; + AOT_Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x188; + AOT_Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xd0; + 0xd8; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x168; + AOT_Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x170; + AOT_Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x160; + AOT_Thread_return_async_stub_offset = 0x168; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x298; + AOT_Thread_predefined_symbols_address_offset = 0x2a8; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x738; + 0x778; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x740; + AOT_Thread_saved_shadow_call_stack_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x750; + AOT_Thread_safepoint_state_offset = 0x790; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c8; + AOT_Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x278; + AOT_Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x6d0; + AOT_Thread_saved_stack_limit_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x6d8; + AOT_Thread_stack_overflow_flags_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x238; + 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x6e8; + AOT_Thread_store_buffer_block_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x670; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6b0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x678; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6b8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x668; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6a8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x680; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x688; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6c8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x690; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x698; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6b0; + 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x6e0; + AOT_Thread_top_exit_frame_info_offset = 0x720; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x50; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x710; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x708; + AOT_Thread_unboxed_runtime_arg_offset = 0x750; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x748; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x770; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x778; + 0x7b0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x270; + AOT_Thread_jump_to_frame_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -19997,13 +20131,14 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, -1, -1, 0x630, 0x638, - 0x640, 0x648, 0x650, -1, 0x658, 0x660, -1, -1}; + 0x650, 0x658, 0x660, 0x668, -1, -1, 0x670, 0x678, + 0x680, 0x688, 0x690, -1, 0x698, 0x6a0, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x10; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x58; @@ -20457,234 +20592,238 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d8; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e8; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x768; + AOT_Thread_active_exception_offset = 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x770; + AOT_Thread_active_stacktrace_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x200; + AOT_Thread_array_write_barrier_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x220; + AOT_Thread_allocate_object_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x138; + AOT_Thread_allocate_object_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x148; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x238; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x148; + AOT_Thread_allocate_object_slow_stub_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x7a8; + 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x150; + AOT_Thread_async_exception_handler_stub_offset = 0x158; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x298; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x88; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x208; + AOT_Thread_call_to_runtime_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xc0; + AOT_Thread_call_to_runtime_stub_offset = 0xc8; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7e0; + 0x820; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x7b0; + AOT_Thread_double_truncate_round_supported_offset = 0x7f0; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7e8; + AOT_Thread_service_extension_stream_offset = 0x828; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x258; + 0x260; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a8; + 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x260; + AOT_Thread_deoptimize_entry_offset = 0x268; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1b0; + AOT_Thread_deoptimize_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2b0; + AOT_Thread_double_abs_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a8; + AOT_Thread_double_negate_address_offset = 0x2b8; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d8; + AOT_Thread_enter_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x790; + AOT_Thread_execution_state_offset = 0x7d0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c8; + AOT_Thread_float_absolute_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2c0; + AOT_Thread_float_negate_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b8; + AOT_Thread_float_not_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2d0; + AOT_Thread_float_zerow_address_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x778; + AOT_Thread_global_object_pool_offset = 0x7b8; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x2a0; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x7a0; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x708; + AOT_Thread_exit_through_ffi_offset = 0x7e0; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x748; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x710; + 0x750; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x738; + AOT_Thread_old_marking_stack_block_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x740; + AOT_Thread_new_marking_stack_block_offset = 0x780; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x250; + AOT_Thread_switchable_call_miss_entry_offset = 0x258; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x188; + AOT_Thread_switchable_call_miss_stub_offset = 0x190; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xd0; + 0xd8; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x158; + 0x160; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x168; + AOT_Thread_return_async_not_future_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x170; + AOT_Thread_return_async_star_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x160; + AOT_Thread_return_async_stub_offset = 0x168; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x298; + AOT_Thread_predefined_symbols_address_offset = 0x2a8; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x780; + 0x7c0; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x788; + AOT_Thread_saved_shadow_call_stack_offset = 0x7c8; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x798; + AOT_Thread_safepoint_state_offset = 0x7d8; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c8; + AOT_Thread_slow_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x278; + AOT_Thread_slow_type_test_entry_point_offset = 0x280; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x718; + AOT_Thread_saved_stack_limit_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x720; + AOT_Thread_stack_overflow_flags_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x188; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x238; + 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x730; + AOT_Thread_store_buffer_block_offset = 0x770; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6e0; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6f0; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x730; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x700; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x728; + AOT_Thread_top_exit_frame_info_offset = 0x768; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x50; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x758; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x750; + AOT_Thread_unboxed_runtime_arg_offset = 0x798; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x790; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_heap_base_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7b8; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7c0; + 0x7f8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x800; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x270; + AOT_Thread_jump_to_frame_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7c8; + 0x808; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -20784,15 +20923,16 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - 0x610, 0x618, 0x620, 0x628, 0x630, 0x638, 0x640, 0x648, - 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, -1, - -1, -1, -1, 0x688, 0x690, -1, -1, 0x698, - 0x6a0, 0x6a8, -1, -1, -1, -1, -1, -1}; + 0x650, 0x658, 0x660, 0x668, 0x670, 0x678, 0x680, 0x688, + 0x690, 0x698, 0x6a0, 0x6a8, 0x6b0, 0x6b8, 0x6c0, -1, + -1, -1, -1, 0x6c8, 0x6d0, -1, -1, 0x6d8, + 0x6e0, 0x6e8, -1, -1, -1, -1, -1, -1}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x20; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x10; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x40; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x58; @@ -21246,232 +21386,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x8; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x168; + AOT_Thread_AllocateArray_entry_point_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x3b0; + AOT_Thread_active_exception_offset = 0x3d0; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x3b4; + AOT_Thread_active_stacktrace_offset = 0x3d4; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0xfc; + AOT_Thread_array_write_barrier_entry_point_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x104; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x90; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x94; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x108; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x10c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x94; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x98; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x10c; + AOT_Thread_allocate_object_entry_point_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x98; + AOT_Thread_allocate_object_stub_offset = 0x9c; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x110; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x114; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x9c; + AOT_Thread_allocate_object_parameterized_stub_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x114; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x118; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0xa0; + AOT_Thread_allocate_object_slow_stub_offset = 0xa4; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x3d0; + 0x3f0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0xa4; + AOT_Thread_async_exception_handler_stub_offset = 0xa8; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x144; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x3c; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x13c; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x100; + AOT_Thread_call_to_runtime_entry_point_offset = 0x104; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0x5c; + AOT_Thread_call_to_runtime_stub_offset = 0x60; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x3f4; + 0x414; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x2c; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x3d4; + AOT_Thread_double_truncate_round_supported_offset = 0x3f4; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x3f8; + AOT_Thread_service_extension_stream_offset = 0x418; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x128; + 0x12c; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0xd0; + 0xd4; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x12c; + AOT_Thread_deoptimize_entry_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0xd4; + AOT_Thread_deoptimize_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x154; + AOT_Thread_double_abs_address_offset = 0x15c; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x150; + AOT_Thread_double_negate_address_offset = 0x158; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x28; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0xe8; + AOT_Thread_enter_safepoint_stub_offset = 0xec; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x3c4; + AOT_Thread_execution_state_offset = 0x3e4; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0xec; + AOT_Thread_exit_safepoint_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0xf4; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0xf4; + AOT_Thread_call_native_through_safepoint_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x130; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x134; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0x54; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x160; + AOT_Thread_float_absolute_address_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x15c; + AOT_Thread_float_negate_address_offset = 0x164; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x158; + AOT_Thread_float_not_address_offset = 0x160; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x164; + AOT_Thread_float_zerow_address_offset = 0x16c; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x3b8; + AOT_Thread_global_object_pool_offset = 0x3d8; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x14c; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0x5c; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x3cc; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x378; + AOT_Thread_exit_through_ffi_offset = 0x3ec; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x398; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x37c; + 0x39c; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x30; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0xd8; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0xdc; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xdc; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe4; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x390; + AOT_Thread_old_marking_stack_block_offset = 0x3b0; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x394; + AOT_Thread_new_marking_stack_block_offset = 0x3b4; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x120; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x124; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x124; + AOT_Thread_switchable_call_miss_entry_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0xc0; + AOT_Thread_switchable_call_miss_stub_offset = 0xc4; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x140; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x144; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0x64; + 0x68; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0x60; + 0x64; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x6c; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x68; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0x6c; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x74; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x70; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0x74; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x7c; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x80; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x78; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0x7c; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x84; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x88; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x80; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x84; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x8c; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x90; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x88; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x8c; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0xa8; + 0xac; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0xb0; + AOT_Thread_return_async_not_future_stub_offset = 0xb4; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0xb4; + AOT_Thread_return_async_star_stub_offset = 0xb8; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0xac; + AOT_Thread_return_async_stub_offset = 0xb0; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x148; + AOT_Thread_predefined_symbols_address_offset = 0x150; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x3bc; + 0x3dc; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x3c0; + AOT_Thread_saved_shadow_call_stack_offset = 0x3e0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x3c8; + AOT_Thread_safepoint_state_offset = 0x3e8; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x34; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0xe0; + AOT_Thread_slow_type_test_stub_offset = 0xe4; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x138; + AOT_Thread_slow_type_test_entry_point_offset = 0x13c; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x1c; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x380; + AOT_Thread_saved_stack_limit_offset = 0x3a0; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x384; + AOT_Thread_stack_overflow_flags_offset = 0x3a4; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x11c; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xbc; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x118; + 0x11c; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xb8; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0xbc; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x38c; + AOT_Thread_store_buffer_block_offset = 0x3ac; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x350; + AOT_Thread_suspend_state_await_entry_point_offset = 0x370; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x354; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x374; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x34c; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x36c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x358; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x378; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x35c; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x37c; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x360; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x380; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x364; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x384; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x368; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x388; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x36c; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x38c; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x370; + 0x390; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x374; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x394; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x388; + AOT_Thread_top_exit_frame_info_offset = 0x3a8; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x24; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x10; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x3a0; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x39c; + AOT_Thread_unboxed_runtime_arg_offset = 0x3c0; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x3bc; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0xf8; + AOT_Thread_write_barrier_entry_point_offset = 0xfc; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x20; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x3d8; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x3e0; + 0x3f8; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x400; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x134; + AOT_Thread_jump_to_frame_entry_point_offset = 0x138; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x3e8; + 0x408; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -21571,14 +21715,15 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x4, 0xc, 0x8, 0x10}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x304, 0x308, 0x30c, -1, -1, 0x310, - 0x314, 0x318, -1, -1, -1, 0x31c, 0x320, 0x324, 0x328, 0x32c, 0x330, - 0x334, 0x338, -1, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348}; + -1, -1, -1, -1, -1, 0x324, 0x328, 0x32c, -1, -1, 0x330, + 0x334, 0x338, -1, -1, -1, 0x33c, 0x340, 0x344, 0x348, 0x34c, 0x350, + 0x354, 0x358, -1, -1, -1, -1, 0x35c, 0x360, 0x364, 0x368}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x14; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x8; static constexpr dart::compiler::target::word AOT_Array_header_size = 0xc; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x8; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x30; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x54; @@ -22031,232 +22176,236 @@ static constexpr dart::compiler::target::word AOT_SuspendState_pc_offset = 0x10; static constexpr dart::compiler::target::word AOT_SuspendState_then_callback_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_AllocateArray_entry_point_offset = 0x2d0; + AOT_Thread_AllocateArray_entry_point_offset = 0x2e0; static constexpr dart::compiler::target::word - AOT_Thread_active_exception_offset = 0x750; + AOT_Thread_active_exception_offset = 0x790; static constexpr dart::compiler::target::word - AOT_Thread_active_stacktrace_offset = 0x758; + AOT_Thread_active_stacktrace_offset = 0x798; static constexpr dart::compiler::target::word - AOT_Thread_array_write_barrier_entry_point_offset = 0x1f8; + AOT_Thread_array_write_barrier_entry_point_offset = 0x200; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x208; + AOT_Thread_allocate_mint_with_fpu_regs_entry_point_offset = 0x210; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x120; + AOT_Thread_allocate_mint_with_fpu_regs_stub_offset = 0x128; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x210; + AOT_Thread_allocate_mint_without_fpu_regs_entry_point_offset = 0x218; static constexpr dart::compiler::target::word - AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x128; + AOT_Thread_allocate_mint_without_fpu_regs_stub_offset = 0x130; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_entry_point_offset = 0x218; + AOT_Thread_allocate_object_entry_point_offset = 0x220; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_stub_offset = 0x130; + AOT_Thread_allocate_object_stub_offset = 0x138; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x220; + AOT_Thread_allocate_object_parameterized_entry_point_offset = 0x228; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_parameterized_stub_offset = 0x138; + AOT_Thread_allocate_object_parameterized_stub_offset = 0x140; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_entry_point_offset = 0x228; + AOT_Thread_allocate_object_slow_entry_point_offset = 0x230; static constexpr dart::compiler::target::word - AOT_Thread_allocate_object_slow_stub_offset = 0x140; + AOT_Thread_allocate_object_slow_stub_offset = 0x148; static constexpr dart::compiler::target::word AOT_Thread_api_top_scope_offset = - 0x790; + 0x7d0; static constexpr dart::compiler::target::word - AOT_Thread_async_exception_handler_stub_offset = 0x148; + AOT_Thread_async_exception_handler_stub_offset = 0x150; static constexpr dart::compiler::target::word - AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x288; + AOT_Thread_auto_scope_native_wrapper_entry_point_offset = 0x290; static constexpr dart::compiler::target::word AOT_Thread_bool_false_offset = 0x80; static constexpr dart::compiler::target::word AOT_Thread_bool_true_offset = 0x78; static constexpr dart::compiler::target::word - AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x278; + AOT_Thread_bootstrap_native_wrapper_entry_point_offset = 0x280; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_entry_point_offset = 0x200; + AOT_Thread_call_to_runtime_entry_point_offset = 0x208; static constexpr dart::compiler::target::word - AOT_Thread_call_to_runtime_stub_offset = 0xb8; + AOT_Thread_call_to_runtime_stub_offset = 0xc0; static constexpr dart::compiler::target::word AOT_Thread_dart_stream_offset = - 0x7c8; + 0x808; static constexpr dart::compiler::target::word AOT_Thread_dispatch_table_array_offset = 0x58; static constexpr dart::compiler::target::word - AOT_Thread_double_truncate_round_supported_offset = 0x798; + AOT_Thread_double_truncate_round_supported_offset = 0x7d8; static constexpr dart::compiler::target::word - AOT_Thread_service_extension_stream_offset = 0x7d0; + AOT_Thread_service_extension_stream_offset = 0x810; static constexpr dart::compiler::target::word AOT_Thread_optimize_entry_offset = - 0x250; + 0x258; static constexpr dart::compiler::target::word AOT_Thread_optimize_stub_offset = - 0x1a0; + 0x1a8; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_entry_offset = 0x258; + AOT_Thread_deoptimize_entry_offset = 0x260; static constexpr dart::compiler::target::word - AOT_Thread_deoptimize_stub_offset = 0x1a8; + AOT_Thread_deoptimize_stub_offset = 0x1b0; static constexpr dart::compiler::target::word - AOT_Thread_double_abs_address_offset = 0x2a8; + AOT_Thread_double_abs_address_offset = 0x2b8; static constexpr dart::compiler::target::word - AOT_Thread_double_negate_address_offset = 0x2a0; + AOT_Thread_double_negate_address_offset = 0x2b0; static constexpr dart::compiler::target::word AOT_Thread_end_offset = 0x50; static constexpr dart::compiler::target::word - AOT_Thread_enter_safepoint_stub_offset = 0x1d0; + AOT_Thread_enter_safepoint_stub_offset = 0x1d8; static constexpr dart::compiler::target::word - AOT_Thread_execution_state_offset = 0x778; + AOT_Thread_execution_state_offset = 0x7b8; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_stub_offset = 0x1d8; + AOT_Thread_exit_safepoint_stub_offset = 0x1e0; static constexpr dart::compiler::target::word - AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e0; + AOT_Thread_exit_safepoint_ignore_unwind_in_progress_stub_offset = 0x1e8; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_stub_offset = 0x1e8; + AOT_Thread_call_native_through_safepoint_stub_offset = 0x1f0; static constexpr dart::compiler::target::word - AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x260; + AOT_Thread_call_native_through_safepoint_entry_point_offset = 0x268; static constexpr dart::compiler::target::word AOT_Thread_fix_allocation_stub_code_offset = 0xa8; static constexpr dart::compiler::target::word AOT_Thread_fix_callers_target_code_offset = 0xa0; static constexpr dart::compiler::target::word - AOT_Thread_float_absolute_address_offset = 0x2c0; + AOT_Thread_float_absolute_address_offset = 0x2d0; static constexpr dart::compiler::target::word - AOT_Thread_float_negate_address_offset = 0x2b8; + AOT_Thread_float_negate_address_offset = 0x2c8; static constexpr dart::compiler::target::word - AOT_Thread_float_not_address_offset = 0x2b0; + AOT_Thread_float_not_address_offset = 0x2c0; static constexpr dart::compiler::target::word - AOT_Thread_float_zerow_address_offset = 0x2c8; + AOT_Thread_float_zerow_address_offset = 0x2d8; static constexpr dart::compiler::target::word - AOT_Thread_global_object_pool_offset = 0x760; + AOT_Thread_global_object_pool_offset = 0x7a0; +static constexpr dart::compiler::target::word + AOT_Thread_interpret_call_entry_point_offset = 0x298; +static constexpr dart::compiler::target::word + AOT_Thread_invoke_dart_code_from_bytecode_stub_offset = 0xb8; static constexpr dart::compiler::target::word AOT_Thread_invoke_dart_code_stub_offset = 0xb0; static constexpr dart::compiler::target::word - AOT_Thread_exit_through_ffi_offset = 0x788; -static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x6f0; + AOT_Thread_exit_through_ffi_offset = 0x7c8; +static constexpr dart::compiler::target::word AOT_Thread_isolate_offset = 0x730; static constexpr dart::compiler::target::word AOT_Thread_isolate_group_offset = - 0x6f8; + 0x738; static constexpr dart::compiler::target::word AOT_Thread_field_table_values_offset = 0x60; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b0; + AOT_Thread_lazy_deopt_from_return_stub_offset = 0x1b8; static constexpr dart::compiler::target::word - AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1b8; + AOT_Thread_lazy_deopt_from_throw_stub_offset = 0x1c0; static constexpr dart::compiler::target::word - AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1c8; + AOT_Thread_lazy_specialize_type_test_stub_offset = 0x1d0; static constexpr dart::compiler::target::word - AOT_Thread_old_marking_stack_block_offset = 0x720; + AOT_Thread_old_marking_stack_block_offset = 0x760; static constexpr dart::compiler::target::word - AOT_Thread_new_marking_stack_block_offset = 0x728; + AOT_Thread_new_marking_stack_block_offset = 0x768; static constexpr dart::compiler::target::word - AOT_Thread_megamorphic_call_checked_entry_offset = 0x240; + AOT_Thread_megamorphic_call_checked_entry_offset = 0x248; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_entry_offset = 0x248; + AOT_Thread_switchable_call_miss_entry_offset = 0x250; static constexpr dart::compiler::target::word - AOT_Thread_switchable_call_miss_stub_offset = 0x180; + AOT_Thread_switchable_call_miss_stub_offset = 0x188; static constexpr dart::compiler::target::word - AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x280; + AOT_Thread_no_scope_native_wrapper_entry_point_offset = 0x288; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_with_fpu_regs_stub_offset = - 0xc8; + 0xd0; static constexpr dart::compiler::target::word AOT_Thread_late_initialization_error_shared_without_fpu_regs_stub_offset = - 0xc0; + 0xc8; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xd8; + AOT_Thread_null_error_shared_with_fpu_regs_stub_offset = 0xe0; static constexpr dart::compiler::target::word - AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd0; + AOT_Thread_null_error_shared_without_fpu_regs_stub_offset = 0xd8; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xe8; + AOT_Thread_null_arg_error_shared_with_fpu_regs_stub_offset = 0xf0; static constexpr dart::compiler::target::word - AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe0; + AOT_Thread_null_arg_error_shared_without_fpu_regs_stub_offset = 0xe8; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0xf8; + AOT_Thread_null_cast_error_shared_with_fpu_regs_stub_offset = 0x100; static constexpr dart::compiler::target::word - AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf0; + AOT_Thread_null_cast_error_shared_without_fpu_regs_stub_offset = 0xf8; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x108; + AOT_Thread_range_error_shared_with_fpu_regs_stub_offset = 0x110; static constexpr dart::compiler::target::word - AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x100; + AOT_Thread_range_error_shared_without_fpu_regs_stub_offset = 0x108; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x118; + AOT_Thread_write_error_shared_with_fpu_regs_stub_offset = 0x120; static constexpr dart::compiler::target::word - AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x110; + AOT_Thread_write_error_shared_without_fpu_regs_stub_offset = 0x118; static constexpr dart::compiler::target::word AOT_Thread_resume_stub_offset = - 0x150; + 0x158; static constexpr dart::compiler::target::word - AOT_Thread_return_async_not_future_stub_offset = 0x160; + AOT_Thread_return_async_not_future_stub_offset = 0x168; static constexpr dart::compiler::target::word - AOT_Thread_return_async_star_stub_offset = 0x168; + AOT_Thread_return_async_star_stub_offset = 0x170; static constexpr dart::compiler::target::word - AOT_Thread_return_async_stub_offset = 0x158; + AOT_Thread_return_async_stub_offset = 0x160; static constexpr dart::compiler::target::word AOT_Thread_object_null_offset = 0x70; static constexpr dart::compiler::target::word - AOT_Thread_predefined_symbols_address_offset = 0x290; + AOT_Thread_predefined_symbols_address_offset = 0x2a0; static constexpr dart::compiler::target::word AOT_Thread_resume_pc_offset = - 0x768; + 0x7a8; static constexpr dart::compiler::target::word - AOT_Thread_saved_shadow_call_stack_offset = 0x770; + AOT_Thread_saved_shadow_call_stack_offset = 0x7b0; static constexpr dart::compiler::target::word - AOT_Thread_safepoint_state_offset = 0x780; + AOT_Thread_safepoint_state_offset = 0x7c0; static constexpr dart::compiler::target::word AOT_Thread_shared_field_table_values_offset = 0x68; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_stub_offset = 0x1c0; + AOT_Thread_slow_type_test_stub_offset = 0x1c8; static constexpr dart::compiler::target::word - AOT_Thread_slow_type_test_entry_point_offset = 0x270; + AOT_Thread_slow_type_test_entry_point_offset = 0x278; static constexpr dart::compiler::target::word AOT_Thread_stack_limit_offset = 0x38; static constexpr dart::compiler::target::word - AOT_Thread_saved_stack_limit_offset = 0x700; + AOT_Thread_saved_stack_limit_offset = 0x740; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_flags_offset = 0x708; + AOT_Thread_stack_overflow_flags_offset = 0x748; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x238; + AOT_Thread_stack_overflow_shared_with_fpu_regs_entry_point_offset = 0x240; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x178; + AOT_Thread_stack_overflow_shared_with_fpu_regs_stub_offset = 0x180; static constexpr dart::compiler::target::word AOT_Thread_stack_overflow_shared_without_fpu_regs_entry_point_offset = - 0x230; + 0x238; static constexpr dart::compiler::target::word - AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x170; + AOT_Thread_stack_overflow_shared_without_fpu_regs_stub_offset = 0x178; static constexpr dart::compiler::target::word - AOT_Thread_store_buffer_block_offset = 0x718; + AOT_Thread_store_buffer_block_offset = 0x758; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_entry_point_offset = 0x6a0; + AOT_Thread_suspend_state_await_entry_point_offset = 0x6e0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6a8; + AOT_Thread_suspend_state_await_with_type_check_entry_point_offset = 0x6e8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_entry_point_offset = 0x698; + AOT_Thread_suspend_state_init_async_entry_point_offset = 0x6d8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6b0; + AOT_Thread_suspend_state_return_async_entry_point_offset = 0x6f0; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6b8; + AOT_Thread_suspend_state_return_async_not_future_entry_point_offset = 0x6f8; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x6c0; + AOT_Thread_suspend_state_init_async_star_entry_point_offset = 0x700; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x6c8; + AOT_Thread_suspend_state_yield_async_star_entry_point_offset = 0x708; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x6d0; + AOT_Thread_suspend_state_return_async_star_entry_point_offset = 0x710; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x6d8; + AOT_Thread_suspend_state_init_sync_star_entry_point_offset = 0x718; static constexpr dart::compiler::target::word AOT_Thread_suspend_state_suspend_sync_star_at_start_entry_point_offset = - 0x6e0; + 0x720; static constexpr dart::compiler::target::word - AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x6e8; + AOT_Thread_suspend_state_handle_exception_entry_point_offset = 0x728; static constexpr dart::compiler::target::word - AOT_Thread_top_exit_frame_info_offset = 0x710; + AOT_Thread_top_exit_frame_info_offset = 0x750; static constexpr dart::compiler::target::word AOT_Thread_top_offset = 0x48; static constexpr dart::compiler::target::word AOT_Thread_top_resource_offset = 0x20; static constexpr dart::compiler::target::word - AOT_Thread_unboxed_runtime_arg_offset = 0x740; -static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x738; + AOT_Thread_unboxed_runtime_arg_offset = 0x780; +static constexpr dart::compiler::target::word AOT_Thread_vm_tag_offset = 0x778; static constexpr dart::compiler::target::word - AOT_Thread_write_barrier_entry_point_offset = 0x1f0; + AOT_Thread_write_barrier_entry_point_offset = 0x1f8; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_mask_offset = 0x40; static constexpr dart::compiler::target::word AOT_Thread_next_task_id_offset = - 0x7a0; -static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7a8; + 0x7e0; +static constexpr dart::compiler::target::word AOT_Thread_random_offset = 0x7e8; static constexpr dart::compiler::target::word - AOT_Thread_jump_to_frame_entry_point_offset = 0x268; + AOT_Thread_jump_to_frame_entry_point_offset = 0x270; static constexpr dart::compiler::target::word AOT_Thread_tsan_utils_offset = - 0x7b0; + 0x7f0; static constexpr dart::compiler::target::word AOT_TsanUtils_setjmp_function_offset = 0x0; static constexpr dart::compiler::target::word @@ -22356,14 +22505,15 @@ static constexpr dart::compiler::target::word AOT_Code_entry_point_offset[] = { 0x8, 0x18, 0x10, 0x20}; static constexpr dart::compiler::target::word AOT_Thread_write_barrier_wrappers_thread_offset[] = { - -1, -1, -1, -1, -1, 0x608, 0x610, 0x618, -1, -1, 0x620, - 0x628, 0x630, -1, -1, -1, 0x638, 0x640, 0x648, 0x650, 0x658, 0x660, - 0x668, 0x670, -1, -1, -1, -1, 0x678, 0x680, 0x688, 0x690}; + -1, -1, -1, -1, -1, 0x648, 0x650, 0x658, -1, -1, 0x660, + 0x668, 0x670, -1, -1, -1, 0x678, 0x680, 0x688, 0x690, 0x698, 0x6a0, + 0x6a8, 0x6b0, -1, -1, -1, -1, 0x6b8, 0x6c0, 0x6c8, 0x6d0}; static constexpr dart::compiler::target::word AOT_AbstractType_InstanceSize = 0x28; static constexpr dart::compiler::target::word AOT_ApiError_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Array_header_size = 0x18; static constexpr dart::compiler::target::word AOT_Bool_InstanceSize = 0x10; +static constexpr dart::compiler::target::word AOT_Bytecode_InstanceSize = 0x58; static constexpr dart::compiler::target::word AOT_Capability_InstanceSize = 0x10; static constexpr dart::compiler::target::word AOT_Class_InstanceSize = 0x90; diff --git a/runtime/vm/compiler/runtime_offsets_list.h b/runtime/vm/compiler/runtime_offsets_list.h index 3e1fcde345d..d8f01a17e03 100644 --- a/runtime/vm/compiler/runtime_offsets_list.h +++ b/runtime/vm/compiler/runtime_offsets_list.h @@ -281,6 +281,8 @@ FIELD(Thread, float_not_address_offset) \ FIELD(Thread, float_zerow_address_offset) \ FIELD(Thread, global_object_pool_offset) \ + FIELD(Thread, interpret_call_entry_point_offset) \ + FIELD(Thread, invoke_dart_code_from_bytecode_stub_offset) \ FIELD(Thread, invoke_dart_code_stub_offset) \ FIELD(Thread, exit_through_ffi_offset) \ FIELD(Thread, isolate_offset) \ @@ -410,6 +412,7 @@ SIZEOF(ApiError, InstanceSize, UntaggedApiError) \ SIZEOF(Array, header_size, UntaggedArray) \ SIZEOF(Bool, InstanceSize, UntaggedBool) \ + SIZEOF(Bytecode, InstanceSize, UntaggedBytecode) \ SIZEOF(Capability, InstanceSize, UntaggedCapability) \ SIZEOF(Class, InstanceSize, UntaggedClass) \ SIZEOF(Closure, InstanceSize, UntaggedClosure) \ diff --git a/runtime/vm/compiler/stub_code_compiler.cc b/runtime/vm/compiler/stub_code_compiler.cc index 2b4c95500b1..705f9bc99ba 100644 --- a/runtime/vm/compiler/stub_code_compiler.cc +++ b/runtime/vm/compiler/stub_code_compiler.cc @@ -150,8 +150,14 @@ void StubCodeCompiler::GenerateInitLateInstanceFieldStub(bool is_final) { if (!FLAG_precompiled_mode) { __ LoadCompressedFieldFromOffset(CODE_REG, FUNCTION_REG, target::Function::code_offset()); +#if defined(DART_DYNAMIC_MODULES) + // InterpretCall stub needs arguments descriptor for all function calls. + __ LoadObject(ARGS_DESC_REG, ArgumentsDescriptorBoxed(/*type_args_len=*/0, + /*num_arguments=*/1)); +#else // Load a GC-safe value for the arguments descriptor (unused but tagged). __ LoadImmediate(ARGS_DESC_REG, 0); +#endif // defined(DART_DYNAMIC_MODULES) } __ Call(FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); __ Drop(1); // Drop argument. diff --git a/runtime/vm/compiler/stub_code_compiler_arm.cc b/runtime/vm/compiler/stub_code_compiler_arm.cc index b22059af85d..8af2e427eea 100644 --- a/runtime/vm/compiler/stub_code_compiler_arm.cc +++ b/runtime/vm/compiler/stub_code_compiler_arm.cc @@ -1227,7 +1227,7 @@ void StubCodeCompiler::GenerateAllocateMintSharedWithoutFPURegsStub() { // Called when invoking Dart code from C++ (VM code). // Input parameters: // LR : points to return address. -// R0 : target code or entry point (in bare instructions mode). +// R0 : target code or entry point (in AOT mode). // R1 : arguments descriptor array. // R2 : arguments array. // R3 : current thread. @@ -1356,6 +1356,143 @@ void StubCodeCompiler::GenerateInvokeDartCodeStub() { __ Ret(); } +// Called when invoking compiled Dart code from interpreted Dart code. +// Input parameters: +// LR : points to return address. +// R0 : target code or entry point (in AOT mode). +// R1 : arguments descriptor array. +// R2 : address of first argument. +// R3 : current thread. +void StubCodeCompiler::GenerateInvokeDartCodeFromBytecodeStub() { +#if defined(DART_DYNAMIC_MODULES) + SPILLS_LR_TO_FRAME(__ EnterFrame((1 << FP) | (1 << LR), 0)); + + // Push code object to PC marker slot. + __ ldr(IP, + Address(R3, + target::Thread::invoke_dart_code_from_bytecode_stub_offset())); + __ Push(IP); + + __ PushNativeCalleeSavedRegisters(); + + // Set up THR, which caches the current thread in Dart code. + if (THR != R3) { + __ mov(THR, Operand(R3)); + } + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + // Save the current VMTag on the stack. + __ LoadFromOffset(R9, THR, target::Thread::vm_tag_offset()); + __ Push(R9); + + // Save top resource and top exit frame info. Use R4-6 as temporary registers. + // StackFrameIterator reads the top exit frame info saved in this frame. + __ LoadFromOffset(R4, THR, target::Thread::top_resource_offset()); + __ Push(R4); + __ LoadImmediate(R8, 0); + __ StoreToOffset(R8, THR, target::Thread::top_resource_offset()); + + __ LoadFromOffset(R8, THR, target::Thread::exit_through_ffi_offset()); + __ Push(R8); + __ LoadImmediate(R8, 0); + __ StoreToOffset(R8, THR, target::Thread::exit_through_ffi_offset()); + + __ LoadFromOffset(R9, THR, target::Thread::top_exit_frame_info_offset()); + __ StoreToOffset(R8, THR, target::Thread::top_exit_frame_info_offset()); + + // target::frame_layout.exit_link_slot_from_entry_fp must be kept in sync + // with the code below. +#if defined(DART_TARGET_OS_MACOS) || defined(DART_TARGET_OS_MACOS_IOS) + ASSERT(target::frame_layout.exit_link_slot_from_entry_fp == -27); +#else + ASSERT(target::frame_layout.exit_link_slot_from_entry_fp == -28); +#endif + __ Push(R9); + + __ EmitEntryFrameVerification(R9); + + // Mark that the thread is executing Dart code. Do this after initializing the + // exit link for the profiler. + __ LoadImmediate(R9, VMTag::kDartTagId); + __ StoreToOffset(R9, THR, target::Thread::vm_tag_offset()); + + // Load arguments descriptor array into R4, which is passed to Dart code. + __ mov(R4, Operand(R1)); + + // Load number of arguments into R9 and adjust count for type arguments. + __ ldr(R3, + FieldAddress(R4, target::ArgumentsDescriptor::type_args_len_offset())); + __ ldr(R9, FieldAddress(R4, target::ArgumentsDescriptor::count_offset())); + __ cmp(R3, Operand(0)); + __ AddImmediate(R9, R9, target::ToRawSmi(1), + NE); // Include the type arguments. + __ SmiUntag(R9); + + // R2 points to first argument. + // Set up arguments for the Dart call. + Label push_arguments; + Label done_push_arguments; + __ CompareImmediate(R9, 0); // check if there are arguments. + __ b(&done_push_arguments, EQ); + __ LoadImmediate(R1, 0); + __ Bind(&push_arguments); + __ ldr(R3, Address(R2)); + __ Push(R3); + __ AddImmediate(R2, target::kWordSize); + __ AddImmediate(R1, 1); + __ cmp(R1, Operand(R9)); + __ b(&push_arguments, LT); + __ Bind(&done_push_arguments); + + // Call the Dart code entrypoint. + if (FLAG_precompiled_mode) { + __ SetupGlobalPoolAndDispatchTable(); + __ LoadImmediate(CODE_REG, 0); // GC safe value into CODE_REG. + } else { + __ LoadImmediate(PP, 0); // GC safe value into PP. + __ mov(CODE_REG, Operand(R0)); + __ ldr(R0, FieldAddress(CODE_REG, target::Code::entry_point_offset())); + } + __ blx(R0); // R4 is the arguments descriptor array. + + // Get rid of arguments pushed on the stack. + __ AddImmediate( + SP, FP, + target::frame_layout.exit_link_slot_from_entry_fp * target::kWordSize); + + // Restore the saved top exit frame info and top resource back into the + // Isolate structure. Uses R9 as a temporary register for this. + __ Pop(R9); + __ StoreToOffset(R9, THR, target::Thread::top_exit_frame_info_offset()); + __ Pop(R9); + __ StoreToOffset(R9, THR, target::Thread::exit_through_ffi_offset()); + __ Pop(R9); + __ StoreToOffset(R9, THR, target::Thread::top_resource_offset()); + + // Restore the current VMTag from the stack. + __ Pop(R4); + __ StoreToOffset(R4, THR, target::Thread::vm_tag_offset()); + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + __ PopNativeCalleeSavedRegisters(); + + __ set_constant_pool_allowed(false); + + // Restore the frame pointer and return. + RESTORES_LR_FROM_FRAME(__ LeaveFrame((1 << FP) | (1 << LR))); + __ Ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // Helper to generate space allocation of context stub. // This does not initialise the fields of the context. // Input: @@ -2656,6 +2793,90 @@ void StubCodeCompiler::GenerateLazyCompileStub() { __ Branch(FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } +// Stub for interpreting a function call. +// R4: Arguments descriptor. +// R0: Function. +void StubCodeCompiler::GenerateInterpretCallStub() { +#if defined(DART_DYNAMIC_MODULES) + + __ EnterStubFrame(); + +#if defined(DEBUG) + { + Label ok; + // Check that we are always entering from Dart code. + __ LoadFromOffset(kWord, R8, THR, target::Thread::vm_tag_offset()); + __ CompareImmediate(R8, VMTag::kDartTagId); + __ b(&ok, EQ); + __ Stop("Not coming from Dart code."); + __ Bind(&ok); + } +#endif + + // Adjust arguments count for type arguments vector. + __ LoadFieldFromOffset(kWord, R2, R4, + target::ArgumentsDescriptor::count_offset()); + __ SmiUntag(R2); + __ LoadFieldFromOffset(kWord, R1, R4, + target::ArgumentsDescriptor::type_args_len_offset()); + __ cmp(R1, Operand(0)); + __ AddImmediate(R2, R2, 1, NE); // Include the type arguments. + + // Compute argv. + __ mov(R3, Operand(R2, LSL, 2)); + __ add(R3, FP, Operand(R3)); + __ AddImmediate(R3, + target::frame_layout.param_end_from_fp * target::kWordSize); + + // Indicate decreasing memory addresses of arguments with negative argc. + __ rsb(R2, R2, Operand(0)); + + // Align frame before entering C++ world. Fifth argument passed on the stack. + __ ReserveAlignedFrameSpace(1 * target::kWordSize); + + // Pass arguments in registers. + // R0: Function. + __ mov(R1, Operand(R4)); // Arguments descriptor. + // R2: Negative argc. + // R3: Argv. + __ str(THR, Address(SP, 0)); // Fifth argument: Thread. + + // Save exit frame information to enable stack walking as we are about + // to transition to Dart VM C++ code. + __ StoreToOffset(kWord, FP, THR, + target::Thread::top_exit_frame_info_offset()); + + // Mark that the thread exited generated code through a runtime call. + __ LoadImmediate(R5, target::Thread::exit_through_runtime_call()); + __ StoreToOffset(kWord, R5, THR, target::Thread::exit_through_ffi_offset()); + + // Mark that the thread is executing VM code. + __ LoadFromOffset(kWord, R5, THR, + target::Thread::interpret_call_entry_point_offset()); + __ StoreToOffset(kWord, R5, THR, target::Thread::vm_tag_offset()); + + __ blx(R5); + + // Mark that the thread is executing Dart code. + __ LoadImmediate(R2, VMTag::kDartTagId); + __ StoreToOffset(kWord, R2, THR, target::Thread::vm_tag_offset()); + + // Mark that the thread has not exited generated Dart code. + __ LoadImmediate(R2, 0); + __ StoreToOffset(kWord, R2, THR, target::Thread::exit_through_ffi_offset()); + + // Reset exit frame information in Isolate's mutator thread structure. + __ StoreToOffset(kWord, R2, THR, + target::Thread::top_exit_frame_info_offset()); + + __ LeaveStubFrame(); + __ Ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // R9: Contains an ICData. void StubCodeCompiler::GenerateICCallBreakpointStub() { #if defined(PRODUCT) @@ -3165,8 +3386,9 @@ void StubCodeCompiler::GenerateICCallThroughCodeStub() { if (FLAG_precompiled_mode) { const intptr_t entry_offset = target::ICData::EntryPointIndexFor(1) * target::kWordSize; - __ LoadCompressed(R0, Address(R8, entry_offset)); - __ Branch(FieldAddress(R0, target::Function::entry_point_offset())); + __ LoadCompressed(FUNCTION_REG, Address(R8, entry_offset)); + __ Branch( + FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } else { const intptr_t code_offset = target::ICData::CodeIndexFor(1) * target::kWordSize; diff --git a/runtime/vm/compiler/stub_code_compiler_arm64.cc b/runtime/vm/compiler/stub_code_compiler_arm64.cc index de4a0ae9281..c607b797836 100644 --- a/runtime/vm/compiler/stub_code_compiler_arm64.cc +++ b/runtime/vm/compiler/stub_code_compiler_arm64.cc @@ -1512,7 +1512,7 @@ void StubCodeCompiler::GenerateAllocateMintSharedWithoutFPURegsStub() { // Called when invoking Dart code from C++ (VM code). // Input parameters: // LR : points to return address. -// R0 : target code or entry point (in bare instructions mode). +// R0 : target code or entry point (in AOT mode). // R1 : arguments descriptor array. // R2 : arguments array. // R3 : current thread. @@ -1653,6 +1653,155 @@ void StubCodeCompiler::GenerateInvokeDartCodeStub() { __ ret(); } +// Called when invoking compiled Dart code from interpreted Dart code. +// Input parameters: +// LR : points to return address. +// R0 : target code or entry point (in AOT mode). +// R1 : arguments descriptor array. +// R2 : address of first argument. +// R3 : current thread. +void StubCodeCompiler::GenerateInvokeDartCodeFromBytecodeStub() { +#if defined(DART_DYNAMIC_MODULES) + __ Comment("InvokeDartCodeFromBytecodeStub"); + + // Copy the C stack pointer (CSP/R31) into the stack pointer we'll actually + // use to access the stack (SP/R15) and set the C stack pointer to near the + // stack limit, loaded from the Thread held in R3, to prevent signal handlers + // from over-writing Dart frames. + __ mov(SP, CSP); + __ SetupCSPFromThread(R3); + __ EnterFrame(0); + + // Push code object to PC marker slot. + __ ldr(TMP, + Address(R3, + target::Thread::invoke_dart_code_from_bytecode_stub_offset())); + __ Push(TMP); + +#if defined(DART_TARGET_OS_FUCHSIA) + __ str(R18, Address(R3, target::Thread::saved_shadow_call_stack_offset())); +#elif defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + __ PushNativeCalleeSavedRegisters(); + + // Set up THR, which caches the current thread in Dart code. + if (THR != R3) { + __ mov(THR, R3); + } + + // Refresh pinned registers (write barrier mask, null, dispatch table, etc). + __ RestorePinnedRegisters(); + + // Save the current VMTag on the stack. + __ LoadFromOffset(R4, THR, target::Thread::vm_tag_offset()); + __ Push(R4); + + // Save top resource and top exit frame info. Use R6 as a temporary register. + // StackFrameIterator reads the top exit frame info saved in this frame. + __ LoadFromOffset(R6, THR, target::Thread::top_resource_offset()); + __ StoreToOffset(ZR, THR, target::Thread::top_resource_offset()); + __ Push(R6); + + __ LoadFromOffset(R6, THR, target::Thread::exit_through_ffi_offset()); + __ Push(R6); + __ StoreToOffset(ZR, THR, target::Thread::exit_through_ffi_offset()); + + __ LoadFromOffset(R6, THR, target::Thread::top_exit_frame_info_offset()); + __ StoreToOffset(ZR, THR, target::Thread::top_exit_frame_info_offset()); + // target::frame_layout.exit_link_slot_from_entry_fp must be kept in sync + // with the code below. +#if defined(DART_TARGET_OS_FUCHSIA) + ASSERT(target::frame_layout.exit_link_slot_from_entry_fp == -24); +#else + ASSERT(target::frame_layout.exit_link_slot_from_entry_fp == -23); +#endif + __ Push(R6); + // In debug mode, verify that we've pushed the top exit frame info at the + // correct offset from FP. + __ EmitEntryFrameVerification(); + + // Mark that the thread is executing Dart code. Do this after initializing the + // exit link for the profiler. + __ LoadImmediate(R6, VMTag::kDartTagId); + __ StoreToOffset(R6, THR, target::Thread::vm_tag_offset()); + + // Load arguments descriptor array into R4, which is passed to Dart code. + __ mov(R4, R1); + + // Load number of arguments into R5 and adjust count for type arguments. + __ LoadCompressedSmiFieldFromOffset( + R5, R4, target::ArgumentsDescriptor::count_offset()); + __ LoadCompressedSmiFieldFromOffset( + R3, R4, target::ArgumentsDescriptor::type_args_len_offset()); + __ SmiUntag(R5); + // Include the type arguments. + __ cmp(R3, Operand(0), kObjectBytes); + __ csinc(R5, R5, R5, EQ); // R5 <- (R3 == 0) ? R5 : R5 + 1 + + // R2 points to first argument. + // Set up arguments for the Dart call. + Label push_arguments; + Label done_push_arguments; + __ cmp(R5, Operand(0)); + __ b(&done_push_arguments, EQ); // check if there are arguments. + __ LoadImmediate(R1, 0); + __ Bind(&push_arguments); + __ ldr(R3, Address(R2)); + __ Push(R3); + __ add(R1, R1, Operand(1)); + __ add(R2, R2, Operand(target::kWordSize)); + __ cmp(R1, Operand(R5)); + __ b(&push_arguments, LT); + __ Bind(&done_push_arguments); + + if (FLAG_precompiled_mode) { + __ SetupGlobalPoolAndDispatchTable(); + __ mov(CODE_REG, ZR); // GC-safe value into CODE_REG. + } else { + // We now load the pool pointer(PP) with a GC safe value as we are about to + // invoke dart code. We don't need a real object pool here. + // Smi zero does not work because ARM64 assumes PP to be untagged. + __ LoadObject(PP, NullObject()); + __ mov(CODE_REG, R0); + __ ldr(R0, FieldAddress(CODE_REG, target::Code::entry_point_offset())); + } + + // Call the Dart code entrypoint. + __ blr(R0); // R4 is the arguments descriptor array. + __ Comment("InvokeDartCodeFromBytecodeStub return"); + + // Get rid of arguments pushed on the stack. + __ AddImmediate( + SP, FP, + target::frame_layout.exit_link_slot_from_entry_fp * target::kWordSize); + + // Restore the saved top exit frame info and top resource back into the + // Isolate structure. Uses R6 as a temporary register for this. + __ Pop(R6); + __ StoreToOffset(R6, THR, target::Thread::top_exit_frame_info_offset()); + __ Pop(R6); + __ StoreToOffset(R6, THR, target::Thread::exit_through_ffi_offset()); + __ Pop(R6); + __ StoreToOffset(R6, THR, target::Thread::top_resource_offset()); + + // Restore the current VMTag from the stack. + __ Pop(R4); + __ StoreToOffset(R4, THR, target::Thread::vm_tag_offset()); + + __ PopNativeCalleeSavedRegisters(); + + // Restore the frame pointer and C stack pointer and return. + __ LeaveFrame(); + __ RestoreCSP(); + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // Helper to generate space allocation of context stub. // This does not initialise the fields of the context. // Input: @@ -3015,6 +3164,101 @@ void StubCodeCompiler::GenerateLazyCompileStub() { __ br(R2); } +// Stub for interpreting a function call. +// R4: Arguments descriptor. +// R0: Function. +void StubCodeCompiler::GenerateInterpretCallStub() { +#if defined(DART_DYNAMIC_MODULES) + + __ SetPrologueOffset(); + __ EnterStubFrame(); + +#if defined(DEBUG) + { + Label ok; + // Check that we are always entering from Dart code. + __ LoadFromOffset(R8, THR, target::Thread::vm_tag_offset()); + __ CompareImmediate(R8, VMTag::kDartTagId); + __ b(&ok, EQ); + __ Stop("Not coming from Dart code."); + __ Bind(&ok); + } +#endif + + // Adjust arguments count for type arguments vector. + __ LoadCompressedSmiFieldFromOffset( + R2, R4, target::ArgumentsDescriptor::count_offset()); + __ SmiUntag(R2); + __ LoadCompressedSmiFieldFromOffset( + R1, R4, target::ArgumentsDescriptor::type_args_len_offset()); + __ cmp(R1, Operand(0)); + __ csinc(R2, R2, R2, EQ); // R2 <- (R1 == 0) ? R2 : R2 + 1. + + // Compute argv. + __ add(R3, ZR, Operand(R2, LSL, 3)); + __ add(R3, FP, Operand(R3)); + __ AddImmediate(R3, + target::frame_layout.param_end_from_fp * target::kWordSize); + + // Indicate decreasing memory addresses of arguments with negative argc. + __ neg(R2, R2); + + // Align frame before entering C++ world. No shadow stack space required. + __ ReserveAlignedFrameSpace(0 * target::kWordSize); + + // Pass arguments in registers. + // R0: Function. + __ mov(R1, R4); // Arguments descriptor. + // R2: Negative argc. + // R3: Argv. + __ mov(R4, THR); // Thread. + + // Save exit frame information to enable stack walking as we are about + // to transition to Dart VM C++ code. + __ StoreToOffset(FP, THR, target::Thread::top_exit_frame_info_offset()); + + // Mark that the thread exited generated code through a runtime call. + __ LoadImmediate(R5, target::Thread::exit_through_runtime_call()); + __ StoreToOffset(R5, THR, target::Thread::exit_through_ffi_offset()); + + // Mark that the thread is executing VM code. + __ LoadFromOffset(R5, THR, + target::Thread::interpret_call_entry_point_offset()); + __ StoreToOffset(R5, THR, target::Thread::vm_tag_offset()); + + // We are entering runtime code, so the C stack pointer must be restored from + // the stack limit to the top of the stack. We cache the stack limit address + // in a callee-saved register. + __ mov(R25, CSP); + __ mov(CSP, SP); + + __ blr(R5); + + // Restore SP and CSP. + __ mov(SP, CSP); + __ mov(CSP, R25); + + // Refresh pinned registers values (inc. write barrier mask and null object). + __ RestorePinnedRegisters(); + + // Mark that the thread is executing Dart code. + __ LoadImmediate(R2, VMTag::kDartTagId); + __ StoreToOffset(R2, THR, target::Thread::vm_tag_offset()); + + // Mark that the thread has not exited generated Dart code. + __ StoreToOffset(ZR, THR, target::Thread::exit_through_ffi_offset()); + + // Reset exit frame information in Isolate's mutator thread structure. + __ StoreToOffset(ZR, THR, target::Thread::top_exit_frame_info_offset()); + + __ LeaveStubFrame(); + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // R5: Contains an ICData. void StubCodeCompiler::GenerateICCallBreakpointStub() { #if defined(PRODUCT) @@ -3482,8 +3726,9 @@ void StubCodeCompiler::GenerateICCallThroughCodeStub() { if (FLAG_precompiled_mode) { const intptr_t entry_offset = target::ICData::EntryPointIndexFor(1) * target::kCompressedWordSize; - __ LoadCompressed(R1, Address(R8, entry_offset)); - __ ldr(R1, FieldAddress(R1, target::Function::entry_point_offset())); + __ LoadCompressed(FUNCTION_REG, Address(R8, entry_offset)); + __ ldr(R1, + FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } else { const intptr_t code_offset = target::ICData::CodeIndexFor(1) * target::kCompressedWordSize; diff --git a/runtime/vm/compiler/stub_code_compiler_ia32.cc b/runtime/vm/compiler/stub_code_compiler_ia32.cc index 8be149fcac5..9e4023a584c 100644 --- a/runtime/vm/compiler/stub_code_compiler_ia32.cc +++ b/runtime/vm/compiler/stub_code_compiler_ia32.cc @@ -1161,6 +1161,137 @@ void StubCodeCompiler::GenerateInvokeDartCodeStub() { __ ret(); } +// Called when invoking compiled Dart code from interpreted Dart code. +// Input parameters: +// ESP : points to return address. +// ESP + 4 : code object of the dart function to call. +// ESP + 8 : arguments descriptor array. +// ESP + 12: address of first argument. +// ESP + 16 : current thread. +void StubCodeCompiler::GenerateInvokeDartCodeFromBytecodeStub() { +#if defined(DART_DYNAMIC_MODULES) + const intptr_t kTargetCodeOffset = 2 * target::kWordSize; + const intptr_t kArgumentsDescOffset = 3 * target::kWordSize; + const intptr_t kArgumentsOffset = 4 * target::kWordSize; + const intptr_t kThreadOffset = 5 * target::kWordSize; + __ EnterFrame(0); + + // Push code object to PC marker slot. + __ movl(EAX, Address(EBP, kThreadOffset)); + __ pushl(Address(EAX, target::Thread::invoke_dart_code_stub_offset())); + + // Save C++ ABI callee-saved registers. + __ pushl(EBX); + __ pushl(ESI); + __ pushl(EDI); + + // Set up THR, which caches the current thread in Dart code. + __ movl(THR, EAX); + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + // Save the current VMTag on the stack. + __ movl(ECX, Assembler::VMTagAddress()); + __ pushl(ECX); + + // Save top resource and top exit frame info. Use EDX as a temporary register. + // StackFrameIterator reads the top exit frame info saved in this frame. + __ movl(EDX, Address(THR, target::Thread::top_resource_offset())); + __ pushl(EDX); + __ movl(Address(THR, target::Thread::top_resource_offset()), Immediate(0)); + __ movl(EAX, Address(THR, target::Thread::exit_through_ffi_offset())); + __ pushl(EAX); + __ movl(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(0)); + // The constant target::frame_layout.exit_link_slot_from_entry_fp must be + // kept in sync with the code below. + ASSERT(target::frame_layout.exit_link_slot_from_entry_fp == -8); + __ movl(EDX, Address(THR, target::Thread::top_exit_frame_info_offset())); + __ pushl(EDX); + __ movl(Address(THR, target::Thread::top_exit_frame_info_offset()), + Immediate(0)); + + // In debug mode, verify that we've pushed the top exit frame info at the + // correct offset from FP. + __ EmitEntryFrameVerification(); + + // Mark that the thread is executing Dart code. Do this after initializing the + // exit link for the profiler. + __ movl(Assembler::VMTagAddress(), Immediate(VMTag::kDartTagId)); + + // Load arguments descriptor array into EDX. + __ movl(EDX, Address(EBP, kArgumentsDescOffset)); + + // Load number of arguments into EBX and adjust count for type arguments. + __ movl(EBX, FieldAddress(EDX, target::ArgumentsDescriptor::count_offset())); + __ cmpl( + FieldAddress(EDX, target::ArgumentsDescriptor::type_args_len_offset()), + Immediate(0)); + Label args_count_ok; + __ j(EQUAL, &args_count_ok, Assembler::kNearJump); + __ addl(EBX, Immediate(target::ToRawSmi(1))); // Include the type arguments. + __ Bind(&args_count_ok); + // Save number of arguments as Smi on stack, replacing ArgumentsDesc. + __ movl(Address(EBP, kArgumentsDescOffset), EBX); + __ SmiUntag(EBX); + + // Set up arguments for the dart call. + Label push_arguments; + Label done_push_arguments; + __ testl(EBX, EBX); // check if there are arguments. + __ j(ZERO, &done_push_arguments, Assembler::kNearJump); + __ movl(EAX, Immediate(0)); + + // Compute address of 'arguments array' data area into EDI. + __ movl(EDI, Address(EBP, kArgumentsOffset)); + + __ Bind(&push_arguments); + __ movl(ECX, Address(EDI, EAX, TIMES_4, 0)); + __ pushl(ECX); + __ incl(EAX); + __ cmpl(EAX, EBX); + __ j(LESS, &push_arguments, Assembler::kNearJump); + __ Bind(&done_push_arguments); + + // Call the dart code entrypoint. + __ movl(EAX, Address(EBP, kTargetCodeOffset)); + __ call(FieldAddress(EAX, target::Code::entry_point_offset())); + + // Read the saved number of passed arguments as Smi. + __ movl(EDX, Address(EBP, kArgumentsDescOffset)); + // Get rid of arguments pushed on the stack. + __ leal(ESP, Address(ESP, EDX, TIMES_2, 0)); // EDX is a Smi. + + // Restore the saved top exit frame info and top resource back into the + // Isolate structure. + __ popl(Address(THR, target::Thread::top_exit_frame_info_offset())); + __ popl(Address(THR, target::Thread::exit_through_ffi_offset())); + __ popl(Address(THR, target::Thread::top_resource_offset())); + + // Restore the current VMTag from the stack. + __ popl(Assembler::VMTagAddress()); + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + // Restore C++ ABI callee-saved registers. + __ popl(EDI); + __ popl(ESI); + __ popl(EBX); + + // Restore the frame pointer. + __ LeaveFrame(); + + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // Helper to generate space allocation of context stub. // This does not initialise the fields of the context. // Input: @@ -2365,6 +2496,86 @@ void StubCodeCompiler::GenerateLazyCompileStub() { __ jmp(FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } +// Stub for interpreting a function call. +// EDX: Arguments descriptor. +// EAX: Function. +void StubCodeCompiler::GenerateInterpretCallStub() { +#if defined(DART_DYNAMIC_MODULES) + + __ EnterStubFrame(); + +#if defined(DEBUG) + { + Label ok; + // Check that we are always entering from Dart code. + __ cmpl(Assembler::VMTagAddress(), Immediate(VMTag::kDartTagId)); + __ j(EQUAL, &ok, Assembler::kNearJump); + __ Stop("Not coming from Dart code."); + __ Bind(&ok); + } +#endif + + // Adjust arguments count for type arguments vector. + __ movl(ECX, FieldAddress(EDX, target::ArgumentsDescriptor::count_offset())); + __ SmiUntag(ECX); + __ cmpl( + FieldAddress(EDX, target::ArgumentsDescriptor::type_args_len_offset()), + Immediate(0)); + Label args_count_ok; + __ j(EQUAL, &args_count_ok, Assembler::kNearJump); + __ incl(ECX); + __ Bind(&args_count_ok); + + // Compute argv. + __ leal(EBX, + Address(EBP, ECX, TIMES_4, + target::frame_layout.param_end_from_fp * target::kWordSize)); + + // Indicate decreasing memory addresses of arguments with negative argc. + __ negl(ECX); + + __ pushl(THR); // Arg 4: Thread. + __ pushl(EBX); // Arg 3: Argv. + __ pushl(ECX); // Arg 2: Negative argc. + __ pushl(EDX); // Arg 1: Arguments descriptor + __ pushl(EAX); // Arg 0: Function + + // Save exit frame information to enable stack walking as we are about + // to transition to Dart VM C++ code. + __ movl(Address(THR, target::Thread::top_exit_frame_info_offset()), EBP); + + // Mark that the thread exited generated code through a runtime call. + __ movl(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(target::Thread::exit_through_runtime_call())); + + // Mark that the thread is executing VM code. + __ movl(EAX, + Address(THR, target::Thread::interpret_call_entry_point_offset())); + __ movl(Assembler::VMTagAddress(), EAX); + + __ call(EAX); + + __ Drop(5); + + // Mark that the thread is executing Dart code. + __ movl(Assembler::VMTagAddress(), Immediate(VMTag::kDartTagId)); + + // Mark that the thread has not exited generated Dart code. + __ movl(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(0)); + + // Reset exit frame information in Isolate's mutator thread structure. + __ movl(Address(THR, target::Thread::top_exit_frame_info_offset()), + Immediate(0)); + + __ LeaveFrame(); + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // ECX: Contains an ICData. void StubCodeCompiler::GenerateICCallBreakpointStub() { #if defined(PRODUCT) diff --git a/runtime/vm/compiler/stub_code_compiler_riscv.cc b/runtime/vm/compiler/stub_code_compiler_riscv.cc index 2cdaba8cd21..1790372a523 100644 --- a/runtime/vm/compiler/stub_code_compiler_riscv.cc +++ b/runtime/vm/compiler/stub_code_compiler_riscv.cc @@ -1341,7 +1341,7 @@ void StubCodeCompiler::GenerateAllocateMintSharedWithoutFPURegsStub() { // Called when invoking Dart code from C++ (VM code). // Input parameters: // RA : points to return address. -// A0 : target code or entry point (in bare instructions mode). +// A0 : target code or entry point (in AOT mode). // A1 : arguments descriptor array. // A2 : arguments array. // A3 : current thread. @@ -1471,6 +1471,17 @@ void StubCodeCompiler::GenerateInvokeDartCodeStub() { __ ret(); } +// Called when invoking compiled Dart code from interpreted Dart code. +// Input parameters: +// RSP : points to return address. +// RDI : target code or entry point (in AOT mode). +// RSI : arguments descriptor array. +// RDX : address of first argument. +// RCX : current thread. +void StubCodeCompiler::GenerateInvokeDartCodeFromBytecodeStub() { + __ Stop("Not implemented on RISC-V."); +} + // Helper to generate space allocation of context stub. // This does not initialise the fields of the context. // Input: @@ -2765,6 +2776,13 @@ void StubCodeCompiler::GenerateLazyCompileStub() { __ jr(TMP); } +// Stub for interpreting a function call. +// ARGS_DESC_REG: Arguments descriptor. +// FUNCTION_REG: Function. +void StubCodeCompiler::GenerateInterpretCallStub() { + __ Stop("Not implemented on RISC-V."); +} + // A0: Receiver // S5: ICData void StubCodeCompiler::GenerateICCallBreakpointStub() { @@ -3243,8 +3261,9 @@ void StubCodeCompiler::GenerateICCallThroughCodeStub() { if (FLAG_precompiled_mode) { const intptr_t entry_offset = target::ICData::EntryPointIndexFor(1) * target::kCompressedWordSize; - __ LoadCompressed(A1, Address(T1, entry_offset)); - __ lx(A1, FieldAddress(A1, target::Function::entry_point_offset())); + __ LoadCompressed(FUNCTION_REG, Address(T1, entry_offset)); + __ lx(A1, + FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } else { const intptr_t code_offset = target::ICData::CodeIndexFor(1) * target::kCompressedWordSize; diff --git a/runtime/vm/compiler/stub_code_compiler_x64.cc b/runtime/vm/compiler/stub_code_compiler_x64.cc index a9135f66e5a..021ccc5388c 100644 --- a/runtime/vm/compiler/stub_code_compiler_x64.cc +++ b/runtime/vm/compiler/stub_code_compiler_x64.cc @@ -1431,7 +1431,7 @@ static const RegisterSet kCalleeSavedRegisterSet( // Called when invoking Dart code from C++ (VM code). // Input parameters: // RSP : points to return address. -// RDI : target code or entry point (in bare instructions mode). +// RDI : target code or entry point (in AOT mode). // RSI : arguments descriptor array. // RDX : arguments array. // RCX : current thread. @@ -1581,6 +1581,161 @@ void StubCodeCompiler::GenerateInvokeDartCodeStub() { __ ret(); } +// Called when invoking compiled Dart code from interpreted Dart code. +// Input parameters: +// RSP : points to return address. +// RDI : target code or entry point (in AOT mode). +// RSI : arguments descriptor array. +// RDX : address of first argument. +// RCX : current thread. +void StubCodeCompiler::GenerateInvokeDartCodeFromBytecodeStub() { +#if defined(DART_DYNAMIC_MODULES) + __ EnterFrame(0); + + const Register kTargetReg = CallingConventions::kArg1Reg; + const Register kArgDescReg = CallingConventions::kArg2Reg; + const Register kArg0Reg = CallingConventions::kArg3Reg; + const Register kThreadReg = CallingConventions::kArg4Reg; + + // Push code object to PC marker slot. + __ pushq( + Address(kThreadReg, + target::Thread::invoke_dart_code_from_bytecode_stub_offset())); + + // At this point, the stack looks like: + // | stub code object + // | saved RBP | <-- RBP + // | saved PC (return to interpreter's InvokeCompiled) | + + const intptr_t kInitialOffset = 2; + // Save arguments descriptor array, later replaced by Smi argument count. + const intptr_t kArgumentsDescOffset = -(kInitialOffset)*target::kWordSize; + __ pushq(kArgDescReg); + + // Save C++ ABI callee-saved registers. + __ PushRegisters(kCalleeSavedRegisterSet); + + // If any additional (or fewer) values are pushed, the offsets in + // target::frame_layout.exit_link_slot_from_entry_fp will need to be changed. + + // Set up THR, which caches the current thread in Dart code. + if (THR != kThreadReg) { + __ movq(THR, kThreadReg); + } + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + // Save the current VMTag on the stack. + __ movq(RAX, Assembler::VMTagAddress()); + __ pushq(RAX); + + // Save top resource and top exit frame info. Use RAX as a temporary register. + // StackFrameIterator reads the top exit frame info saved in this frame. + __ movq(RAX, Address(THR, target::Thread::top_resource_offset())); + __ pushq(RAX); + __ movq(Address(THR, target::Thread::top_resource_offset()), Immediate(0)); + + __ movq(RAX, Address(THR, target::Thread::exit_through_ffi_offset())); + __ pushq(RAX); + __ movq(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(0)); + + __ movq(RAX, Address(THR, target::Thread::top_exit_frame_info_offset())); + __ pushq(RAX); + + // The constant target::frame_layout.exit_link_slot_from_entry_fp must be kept + // in sync with the code above. + __ EmitEntryFrameVerification(); + + __ movq(Address(THR, target::Thread::top_exit_frame_info_offset()), + Immediate(0)); + + // Mark that the thread is executing Dart code. Do this after initializing the + // exit link for the profiler. + __ movq(Assembler::VMTagAddress(), Immediate(VMTag::kDartTagId)); + + // Load arguments descriptor array into R10, which is passed to Dart code. + __ movq(R10, kArgDescReg); + + // Push arguments. At this point we only need to preserve kTargetReg. + ASSERT(kTargetReg != RDX); + + // Load number of arguments into RBX and adjust count for type arguments. + __ OBJ(mov)(RBX, + FieldAddress(R10, target::ArgumentsDescriptor::count_offset())); + __ OBJ(cmp)( + FieldAddress(R10, target::ArgumentsDescriptor::type_args_len_offset()), + Immediate(0)); + Label args_count_ok; + __ j(EQUAL, &args_count_ok, Assembler::kNearJump); + __ addq(RBX, Immediate(target::ToRawSmi(1))); // Include the type arguments. + __ Bind(&args_count_ok); + // Save number of arguments as Smi on stack, replacing saved ArgumentsDesc. + __ movq(Address(RBP, kArgumentsDescOffset), RBX); + __ SmiUntag(RBX); + + // Compute address of first argument into RDX. + __ MoveRegister(RDX, kArg0Reg); + + // Set up arguments for the Dart call. + Label push_arguments; + Label done_push_arguments; + __ j(ZERO, &done_push_arguments, Assembler::kNearJump); + __ LoadImmediate(RAX, Immediate(0)); + __ Bind(&push_arguments); + __ pushq(Address(RDX, RAX, TIMES_8, 0)); + __ incq(RAX); + __ cmpq(RAX, RBX); + __ j(LESS, &push_arguments, Assembler::kNearJump); + __ Bind(&done_push_arguments); + + // Call the Dart code entrypoint. + if (FLAG_precompiled_mode) { + __ movq(PP, Address(THR, target::Thread::global_object_pool_offset())); + __ xorq(CODE_REG, CODE_REG); // GC-safe value into CODE_REG. + } else { + __ xorq(PP, PP); // GC-safe value into PP. + __ movq(CODE_REG, kTargetReg); + __ movq(kTargetReg, + FieldAddress(CODE_REG, target::Code::entry_point_offset())); + } + __ call(kTargetReg); // R10 is the arguments descriptor array. + + // Read the saved number of passed arguments as Smi. + __ movq(RDX, Address(RBP, kArgumentsDescOffset)); + + // Get rid of arguments pushed on the stack. + __ leaq(RSP, Address(RSP, RDX, TIMES_4, 0)); // RDX is a Smi. + + // Restore the saved top exit frame info and top resource back into the + // Isolate structure. + __ popq(Address(THR, target::Thread::top_exit_frame_info_offset())); + __ popq(Address(THR, target::Thread::exit_through_ffi_offset())); + __ popq(Address(THR, target::Thread::top_resource_offset())); + + // Restore the current VMTag from the stack. + __ popq(Assembler::VMTagAddress()); + +#if defined(USING_SHADOW_CALL_STACK) +#error Unimplemented +#endif + + // Restore C++ ABI callee-saved registers. + __ PopRegisters(kCalleeSavedRegisterSet); + __ set_constant_pool_allowed(false); + + // Restore the frame pointer. + __ LeaveFrame(); + + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // Helper to generate space allocation of context stub. // This does not initialize the fields of the context. // Input: @@ -2898,6 +3053,97 @@ void StubCodeCompiler::GenerateLazyCompileStub() { __ jmp(RCX); } +// Stub for interpreting a function call. +// ARGS_DESC_REG: Arguments descriptor. +// FUNCTION_REG: Function. +void StubCodeCompiler::GenerateInterpretCallStub() { +#if defined(DART_DYNAMIC_MODULES) + + __ EnterStubFrame(); + +#if defined(DEBUG) + { + Label ok; + // Check that we are always entering from Dart code. + __ movq(R8, Immediate(VMTag::kDartTagId)); + __ cmpq(R8, Assembler::VMTagAddress()); + __ j(EQUAL, &ok, Assembler::kNearJump); + __ Stop("Not coming from Dart code."); + __ Bind(&ok); + } +#endif + + // Adjust arguments count for type arguments vector. + __ OBJ(mov)(R11, FieldAddress(ARGS_DESC_REG, + target::ArgumentsDescriptor::count_offset())); + __ SmiUntag(R11); + __ OBJ(cmp)(FieldAddress(ARGS_DESC_REG, + target::ArgumentsDescriptor::type_args_len_offset()), + Immediate(0)); + Label args_count_ok; + __ j(EQUAL, &args_count_ok, Assembler::kNearJump); + __ incq(R11); + __ Bind(&args_count_ok); + + // Compute argv. + __ leaq(R12, + Address(RBP, R11, TIMES_8, + target::frame_layout.param_end_from_fp * target::kWordSize)); + + // Indicate decreasing memory addresses of arguments with negative argc. + __ negq(R11); + + // Reserve shadow space for args and align frame before entering C++ world. + __ subq(RSP, Immediate(5 * target::kWordSize)); + if (OS::ActivationFrameAlignment() > 1) { + __ andq(RSP, Immediate(~(OS::ActivationFrameAlignment() - 1))); + } + + __ movq(CallingConventions::kArg1Reg, FUNCTION_REG); // Function. + __ movq(CallingConventions::kArg2Reg, + ARGS_DESC_REG); // Arguments descriptor. + __ movq(CallingConventions::kArg3Reg, R11); // Negative argc. + __ movq(CallingConventions::kArg4Reg, R12); // Argv. + +#if defined(TARGET_OS_WINDOWS) + __ movq(Address(RSP, 0 * target::kWordSize), THR); // Thread. +#else + __ movq(CallingConventions::kArg5Reg, THR); // Thread. +#endif + // Save exit frame information to enable stack walking as we are about + // to transition to Dart VM C++ code. + __ movq(Address(THR, target::Thread::top_exit_frame_info_offset()), RBP); + + // Mark that the thread exited generated code through a runtime call. + __ movq(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(target::Thread::exit_through_runtime_call())); + + // Mark that the thread is executing VM code. + __ movq(RAX, + Address(THR, target::Thread::interpret_call_entry_point_offset())); + __ movq(Assembler::VMTagAddress(), RAX); + + __ call(RAX); + + // Mark that the thread is executing Dart code. + __ movq(Assembler::VMTagAddress(), Immediate(VMTag::kDartTagId)); + + // Mark that the thread has not exited generated Dart code. + __ movq(Address(THR, target::Thread::exit_through_ffi_offset()), + Immediate(0)); + + // Reset exit frame information in Isolate's mutator thread structure. + __ movq(Address(THR, target::Thread::top_exit_frame_info_offset()), + Immediate(0)); + + __ LeaveStubFrame(); + __ ret(); + +#else + __ Stop("Not using Dart dynamic modules"); +#endif // defined(DART_DYNAMIC_MODULES) +} + // RBX: Contains an ICData. // TOS(0): return address (Dart code). void StubCodeCompiler::GenerateICCallBreakpointStub() { @@ -3399,8 +3645,8 @@ void StubCodeCompiler::GenerateICCallThroughCodeStub() { if (FLAG_precompiled_mode) { const intptr_t entry_offset = target::ICData::EntryPointIndexFor(1) * target::kCompressedWordSize; - __ LoadCompressed(RCX, Address(R13, entry_offset)); - __ jmp(FieldAddress(RCX, target::Function::entry_point_offset())); + __ LoadCompressed(FUNCTION_REG, Address(R13, entry_offset)); + __ jmp(FieldAddress(FUNCTION_REG, target::Function::entry_point_offset())); } else { const intptr_t code_offset = target::ICData::CodeIndexFor(1) * target::kCompressedWordSize; diff --git a/runtime/vm/constants_kbc.cc b/runtime/vm/constants_kbc.cc new file mode 100644 index 00000000000..b4ae6649ef0 --- /dev/null +++ b/runtime/vm/constants_kbc.cc @@ -0,0 +1,64 @@ +// Copyright (c) 2024, 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/constants_kbc.h" + +namespace dart { + +static const intptr_t kInstructionSize0 = 1; +static const intptr_t kInstructionSizeA = 2; +static const intptr_t kInstructionSizeD = 2; +static const intptr_t kInstructionSizeWideD = 5; +static const intptr_t kInstructionSizeX = 2; +static const intptr_t kInstructionSizeWideX = 5; +static const intptr_t kInstructionSizeT = 2; +static const intptr_t kInstructionSizeWideT = 4; +static const intptr_t kInstructionSizeA_E = 3; +static const intptr_t kInstructionSizeWideA_E = 6; +static const intptr_t kInstructionSizeA_Y = 3; +static const intptr_t kInstructionSizeWideA_Y = 6; +static const intptr_t kInstructionSizeD_F = 3; +static const intptr_t kInstructionSizeWideD_F = 6; +static const intptr_t kInstructionSizeA_B_C = 4; + +const intptr_t KernelBytecode::kInstructionSize[] = { +#define SIZE_ORDN(encoding) kInstructionSize##encoding +#define SIZE_WIDE(encoding) kInstructionSizeWide##encoding +#define SIZE_RESV(encoding) SIZE_ORDN(encoding) +#define SIZE(name, encoding, kind, op1, op2, op3) SIZE_##kind(encoding), + KERNEL_BYTECODES_LIST(SIZE) +#undef SIZE_ORDN +#undef SIZE_WIDE +#undef SIZE_RESV +#undef SIZE +}; + +#define DECLARE_INSTRUCTIONS(name, fmt, kind, fmta, fmtb, fmtc) \ + static const KBCInstr k##name##Instructions[] = { \ + KernelBytecode::k##name, \ + KernelBytecode::kReturnTOS, \ + }; +INTERNAL_KERNEL_BYTECODES_LIST(DECLARE_INSTRUCTIONS) +#undef DECLARE_INSTRUCTIONS + +void KernelBytecode::GetVMInternalBytecodeInstructions( + Opcode opcode, + const KBCInstr** instructions, + intptr_t* instructions_size) { + switch (opcode) { +#define CASE(name, fmt, kind, fmta, fmtb, fmtc) \ + case k##name: \ + *instructions = k##name##Instructions; \ + *instructions_size = sizeof(k##name##Instructions); \ + return; + + INTERNAL_KERNEL_BYTECODES_LIST(CASE) +#undef CASE + + default: + UNREACHABLE(); + } +} + +} // namespace dart diff --git a/runtime/vm/constants_kbc.h b/runtime/vm/constants_kbc.h new file mode 100644 index 00000000000..e3905f7fa69 --- /dev/null +++ b/runtime/vm/constants_kbc.h @@ -0,0 +1,977 @@ +// Copyright (c) 2024, 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_CONSTANTS_KBC_H_ +#define RUNTIME_VM_CONSTANTS_KBC_H_ + +#include "platform/assert.h" +#include "platform/globals.h" +#include "platform/utils.h" + +namespace dart { + +// clang-format off +// List of KernelBytecode instructions. +// +// INTERPRETER STATE +// +// current frame info (see stack_frame_kbc.h for layout) +// v-----^-----v +// ~----+----~ ~----+-------+-------+-~ ~-+-------+-------+-~ +// ~ | ~ ~ | FP[0] | FP[1] | ~ ~ | SP[-1]| SP[0] | +// ~----+----~ ~----+-------+-------+-~ ~-+-------+-------+-~ +// ^ ^ +// FP SP +// +// +// The state of execution is captured in few interpreter registers: +// +// FP - base of the current frame +// SP - top of the stack (TOS) for the current frame +// PP - object pool for the currently execution function +// +// Frame info stored below FP additionally contains pointers to the currently +// executing function and code. +// +// In the unoptimized code most of bytecodes take operands implicitly from +// stack and store results again on the stack. Constant operands are usually +// taken from the object pool by index. +// +// ENCODING +// +// Each instruction starts with opcode byte. Certain instructions have +// wide encoding variant. In such case, the least significant bit of opcode is +// not set for compact variant and set for wide variant. +// +// The following operand encodings are used: +// +// 0........8.......16.......24.......32.......40.......48 +// +--------+ +// | opcode | 0: no operands +// +--------+ +// +// +--------+--------+ +// | opcode | A | A: unsigned 8-bit operand +// +--------+--------+ +// +// +--------+--------+ +// | opcode | D | D: unsigned 8/32-bit operand +// +--------+--------+ +// +// +--------+----------------------------------+ +// | opcode | D | D (wide) +// +--------+----------------------------------+ +// +// +--------+--------+ +// | opcode | X | X: signed 8/32-bit operand +// +--------+--------+ +// +// +--------+----------------------------------+ +// | opcode | X | X (wide) +// +--------+----------------------------------+ +// +// +--------+--------+ +// | opcode | T | T: signed 8/24-bit operand +// +--------+--------+ +// +// +--------+--------------------------+ +// | opcode | T | T (wide) +// +--------+--------------------------+ +// +// +--------+--------+--------+ +// | opcode | A | E | A_E: unsigned 8-bit operand and +// +--------+--------+--------+ unsigned 8/32-bit operand +// +// +--------+--------+----------------------------------+ +// | opcode | A | E | A_E (wide) +// +--------+--------+----------------------------------+ +// +// +--------+--------+--------+ +// | opcode | A | Y | A_Y: unsigned 8-bit operand and +// +--------+--------+--------+ signed 8/32-bit operand +// +// +--------+--------+----------------------------------+ +// | opcode | A | Y | A_Y (wide) +// +--------+--------+----------------------------------+ +// +// +--------+--------+--------+ +// | opcode | D | F | D_F: unsigned 8/32-bit operand and +// +--------+--------+--------+ unsigned 8-bit operand +// +// +--------+----------------------------------+--------+ +// | opcode | D | F | D_F (wide) +// +--------+----------------------------------+--------+ +// +// +--------+--------+--------+--------+ +// | opcode | A | B | C | A_B_C: 3 unsigned 8-bit operands +// +--------+--------+--------+--------+ +// +// +// INSTRUCTIONS +// +// - Trap +// +// Unreachable instruction. +// +// - Entry rD +// +// Function prologue for the function +// rD - number of local slots to reserve; +// +// - EntryOptional A, B, C +// +// Function prologue for the function with optional or named arguments: +// A - expected number of positional arguments; +// B - number of optional arguments; +// C - number of named arguments; +// +// Only one of B and C can be not 0. +// +// If B is not 0 then EntryOptional bytecode is followed by B LoadConstant +// bytecodes specifying default values for optional arguments. +// +// If C is not 0 then EntryOptional is followed by 2 * C LoadConstant +// bytecodes. +// Bytecode at 2 * i specifies name of the i-th named argument and at +// 2 * i + 1 default value. rA part of the LoadConstant bytecode specifies +// the location of the parameter on the stack. Here named arguments are +// sorted alphabetically to enable linear matching similar to how function +// prologues are implemented on other architectures. +// +// Note: Unlike Entry bytecode EntryOptional does not setup the frame for +// local variables this is done by a separate bytecode Frame, which should +// follow EntryOptional and its LoadConstant instructions. +// +// - EntrySuspendable A, B, C +// +// Similar to EntryOptional, but also reserves a local variable slot +// for suspend state variable. +// +// - LoadConstant rA, D +// +// Used in conjunction with EntryOptional instruction to describe names and +// default values of optional parameters. +// +// - Frame D +// +// Reserve and initialize with null space for D local variables. +// +// - CheckFunctionTypeArgs A, D +// +// Check for a passed-in type argument vector of length A and +// store it at FP[D]. +// +// - CheckStack A +// +// Compare SP against isolate stack limit and call StackOverflow handler if +// necessary. Should be used in prologue (A = 0), or at the beginning of +// a loop with depth A. +// +// - Allocate D +// +// Allocate object of class PP[D] with no type arguments. +// +// - AllocateT +// +// Allocate object of class SP[0] with type arguments SP[-1]. +// +// - CreateArrayTOS +// +// Allocate array of length SP[0] with type arguments SP[-1]. +// +// - AllocateContext A, D +// +// Allocate Context object holding D context variables. +// A is a static ID of the context. Static ID of a context may be used to +// disambiguate accesses to different context objects. +// Context objects with the same ID should have the same number of +// context variables. +// +// - CloneContext A, D +// +// Clone Context object SP[0] holding D context variables. +// A is a static ID of the context. Cloned context has the same ID. +// +// - LoadContextParent +// +// Load parent from context SP[0]. +// +// - StoreContextParent +// +// Store context SP[0] into `parent` field of context SP[-1]. +// +// - LoadContextVar A, D +// +// Load value from context SP[0] at index D. +// A is a static ID of the context. +// +// - StoreContextVar A, D +// +// Store value SP[0] into context SP[-1] at index D. +// A is a static ID of the context. +// +// - PushConstant D +// +// Push value at index D from constant pool onto the stack. +// +// - PushNull +// +// Push `null` onto the stack. +// +// - PushTrue +// +// Push `true` onto the stack. +// +// - PushFalse +// +// Push `false` onto the stack. +// +// - PushInt rX +// +// Push int rX onto the stack. +// +// - Drop1 +// +// Drop 1 value from the stack +// +// - Push rX +// +// Push FP[rX] to the stack. +// +// - StoreLocal rX; PopLocal rX +// +// Store top of the stack into FP[rX] and pop it if needed. +// +// - LoadFieldTOS D +// +// Push value at offset (in words) PP[D] from object SP[0]. +// +// - StoreFieldTOS D +// +// Store value SP[0] into object SP[-1] at offset (in words) PP[D]. +// +// - StoreIndexedTOS +// +// Store SP[0] into array SP[-2] at index SP[-1]. No typechecking is done. +// SP[-2] is assumed to be a RawArray, SP[-1] to be a smi. +// +// - PushStatic D +// +// Pushes value of the static field PP[D] on to the stack. +// +// - StoreStaticTOS D +// +// Stores TOS into the static field PP[D]. +// +// - Jump target +// +// Jump to the given target. Target is specified as offset from the PC of the +// jump instruction. +// +// - JumpIfNoAsserts target +// +// Jump to the given target if assertions are not enabled. +// Target is specified as offset from the PC of the jump instruction. +// +// - JumpIfNotZeroTypeArgs target +// +// Jump to the given target if number of passed function type +// arguments is not zero. +// Target is specified as offset from the PC of the jump instruction. +// +// - JumpIfEqStrict target; JumpIfNeStrict target +// +// Jump to the given target if SP[-1] is the same (JumpIfEqStrict) / +// not the same (JumpIfNeStrict) object as SP[0]. +// +// - JumpIfTrue target; JumpIfFalse target +// - JumpIfNull target; JumpIfNotNull target +// +// Jump to the given target if SP[0] is true/false/null/not null. +// +// - IndirectStaticCall ArgC, D +// +// Invoke the function given by the ICData in SP[0] with arguments +// SP[-(1+ArgC)], ..., SP[-1] and argument descriptor PP[D], which +// indicates whether the first argument is a type argument vector. +// +// - DirectCall ArgC, D +// +// Invoke the function PP[D] with arguments +// SP[-(ArgC-1)], ..., SP[0] and argument descriptor PP[D+1]. +// +// - InterfaceCall ArgC, D +// +// Lookup and invoke method using ICData in PP[D] +// with arguments SP[-(1+ArgC)], ..., SP[-1]. +// Method has to be declared (explicitly or implicitly) in an interface +// implemented by a receiver, and passed arguments are valid for the +// interface method declaration. +// The ICData indicates whether the first argument is a type argument vector. +// +// - UncheckedInterfaceCall ArgC, D +// +// Same as InterfaceCall, but can omit type checks of generic-covariant +// parameters. +// +// - DynamicCall ArgC, D +// +// Lookup and invoke method using ICData in PP[D] +// with arguments SP[-(1+ArgC)], ..., SP[-1]. +// The ICData indicates whether the first argument is a type argument vector. +// +// - ReturnTOS +// +// Return to the caller using a value from the top-of-stack as a result. +// +// Note: return instruction knows how many arguments to remove from the +// stack because it can look at the call instruction at caller's PC and +// take argument count from it. +// +// - ReturnAsync +// +// Return to the caller from async function using a value from +// the top-of-stack as a result. +// +// - ReturnAsyncStar +// +// Return to the caller from async* function using a value from +// the top-of-stack as a result. +// +// - ReturnSyncStar +// +// Return to the caller from sync* function using a value from +// the top-of-stack as a result. +// +// - AssertAssignable A, D +// +// Assert that instance SP[-4] is assignable to variable named SP[0] of +// type SP[-1] with instantiator type arguments SP[-3] and function type +// arguments SP[-2] using SubtypeTestCache PP[D]. +// If A is 1, then the instance may be a Smi. +// +// Instance remains on stack. Other arguments are consumed. +// +// - AssertBoolean A +// +// Assert that TOS is a boolean (A = 1) or that TOS is not null (A = 0). +// +// - AssertSubtype +// +// Assert that one type is a subtype of another. Throws a TypeError +// otherwise. The stack has the following arguments on it: +// +// SP[-4] instantiator type args +// SP[-3] function type args +// SP[-2] sub_type +// SP[-1] super_type +// SP[-0] dst_name +// +// All 5 arguments are consumed from the stack and no results is pushed. +// +// - LoadTypeArgumentsField D +// +// Load instantiator type arguments from an instance SP[0]. +// PP[D] = offset (in words) of type arguments field corresponding +// to an instance's class. +// +// - InstantiateType D +// +// Instantiate type PP[D] with instantiator type arguments SP[-1] and +// function type arguments SP[0]. +// +// - InstantiateTypeArgumentsTOS A, D +// +// Instantiate type arguments PP[D] with instantiator type arguments SP[-1] +// and function type arguments SP[0]. A != 0 indicates that resulting type +// arguments are all dynamic if both instantiator and function type +// arguments are all dynamic. +// +// - Throw A +// +// Throw (Rethrow if A != 0) exception. Exception object and stack object +// are taken from TOS. +// +// - MoveSpecial A, rX +// +// Copy value from special variable to FP[rX]. Currently only +// used to pass exception object (A = 0) and stack trace object (A = 1) to +// catch handler. +// +// - SetFrame A +// +// Reinitialize SP assuming that current frame has size A. +// Used to drop temporaries from the stack in the exception handler. +// +// - BooleanNegateTOS +// +// SP[0] = !SP[0] +// +// - EqualsNull +// +// SP[0] = (SP[0] == null) ? true : false +// +// - NegateInt +// +// Equivalent to invocation of unary int operator-. +// Receiver should have static type int. +// Check SP[0] for null; SP[0] = -SP[0]. +// +// - AddInt; SubInt; MulInt; TruncDivInt; ModInt; BitAndInt; BitOrInt; +// BitXorInt; ShlInt; ShrInt +// +// Equivalent to invocation of binary int operator +, -, *, ~/, %, &, |, +// ^, << or >>. Receiver and argument should have static type int. +// Check SP[-1] and SP[0] for null; push SP[-1] SP[0]. +// +// - CompareIntEq; CompareIntGt; CompareIntLt; CompareIntGe; CompareIntLe +// +// Equivalent to invocation of binary int operator ==, >, <, >= or <=. +// Receiver and argument should have static type int. +// Check SP[-1] and SP[0] for null; push SP[-1] SP[0] ? true : false. +// +// - NegateDouble +// +// Equivalent to invocation of unary double operator-. +// Receiver should have static type double. +// Check SP[0] for null; SP[0] = -SP[0]. +// +// - AddDouble; SubDouble; MulDouble; DivDouble +// +// Equivalent to invocation of binary int operator +, -, *, /. +// Receiver and argument should have static type double. +// Check SP[-1] and SP[0] for null; push SP[-1] SP[0]. +// +// - CompareDoubleEq; CompareDoubleGt; CompareDoubleLt; CompareDoubleGe; +// CompareDoubleLe +// +// Equivalent to invocation of binary double operator ==, >, <, >= or <=. +// Receiver and argument should have static type double. +// Check SP[-1] and SP[0] for null; push SP[-1] SP[0] ? true : false. +// +// - AllocateClosure D +// +// Allocate closure object for closure function ConstantPool[D]. +// +// BYTECODE LIST FORMAT +// +// KernelBytecode list below is specified using the following format: +// +// V(BytecodeName, OperandForm, BytecodeKind, Op1, Op2, Op3) +// +// - OperandForm specifies operand encoding and should be one of 0, A, D, X, T, +// A_E, A_Y, D_F or A_B_C (see ENCODING section above). +// +// - BytecodeKind is one of WIDE, RESV (reserved), ORDN (ordinary) +// +// - Op1, Op2, Op3 specify operand meaning. Possible values: +// +// ___ ignored / non-existent operand +// num immediate operand +// lit constant literal from object pool +// reg register (unsigned FP relative local) +// xeg x-register (signed FP relative local) +// tgt jump target relative to the PC of the current instruction +// +// TODO(vegorov) jump targets should be encoded relative to PC of the next +// instruction because PC is incremented immediately after fetch +// and before decoding. +// +#define PUBLIC_KERNEL_BYTECODES_LIST(V) \ + V(Trap, 0, ORDN, ___, ___, ___) \ + V(Unused00, 0, RESV, ___, ___, ___) \ + V(Entry, D, ORDN, num, ___, ___) \ + V(Entry_Wide, D, WIDE, num, ___, ___) \ + V(EntryOptional, A_B_C, ORDN, num, num, num) \ + V(EntrySuspendable, A_B_C, ORDN, num, num, num) \ + V(LoadConstant, A_E, ORDN, reg, lit, ___) \ + V(LoadConstant_Wide, A_E, WIDE, reg, lit, ___) \ + V(Frame, D, ORDN, num, ___, ___) \ + V(Frame_Wide, D, WIDE, num, ___, ___) \ + V(CheckFunctionTypeArgs, A_E, ORDN, num, reg, ___) \ + V(CheckFunctionTypeArgs_Wide, A_E, WIDE, num, reg, ___) \ + V(CheckStack, A, ORDN, num, ___, ___) \ + V(DebugCheck, 0, ORDN, ___, ___, ___) \ + V(JumpIfUnchecked, T, ORDN, tgt, ___, ___) \ + V(JumpIfUnchecked_Wide, T, WIDE, tgt, ___, ___) \ + V(Allocate, D, ORDN, lit, ___, ___) \ + V(Allocate_Wide, D, WIDE, lit, ___, ___) \ + V(AllocateT, 0, ORDN, ___, ___, ___) \ + V(CreateArrayTOS, 0, ORDN, ___, ___, ___) \ + V(AllocateClosure, D, ORDN, lit, ___, ___) \ + V(AllocateClosure_Wide, D, WIDE, lit, ___, ___) \ + V(AllocateContext, A_E, ORDN, num, num, ___) \ + V(AllocateContext_Wide, A_E, WIDE, num, num, ___) \ + V(CloneContext, A_E, ORDN, num, num, ___) \ + V(CloneContext_Wide, A_E, WIDE, num, num, ___) \ + V(LoadContextParent, 0, ORDN, ___, ___, ___) \ + V(StoreContextParent, 0, ORDN, ___, ___, ___) \ + V(LoadContextVar, A_E, ORDN, num, num, ___) \ + V(LoadContextVar_Wide, A_E, WIDE, num, num, ___) \ + V(Unused04, 0, RESV, ___, ___, ___) \ + V(Unused05, 0, RESV, ___, ___, ___) \ + V(StoreContextVar, A_E, ORDN, num, num, ___) \ + V(StoreContextVar_Wide, A_E, WIDE, num, num, ___) \ + V(PushConstant, D, ORDN, lit, ___, ___) \ + V(PushConstant_Wide, D, WIDE, lit, ___, ___) \ + V(Unused06, 0, RESV, ___, ___, ___) \ + V(Unused07, 0, RESV, ___, ___, ___) \ + V(PushTrue, 0, ORDN, ___, ___, ___) \ + V(PushFalse, 0, ORDN, ___, ___, ___) \ + V(PushInt, X, ORDN, num, ___, ___) \ + V(PushInt_Wide, X, WIDE, num, ___, ___) \ + V(Unused08, 0, RESV, ___, ___, ___) \ + V(Unused09, 0, RESV, ___, ___, ___) \ + V(Unused10, 0, RESV, ___, ___, ___) \ + V(Unused11, 0, RESV, ___, ___, ___) \ + V(PushNull, 0, ORDN, ___, ___, ___) \ + V(Drop1, 0, ORDN, ___, ___, ___) \ + V(Push, X, ORDN, xeg, ___, ___) \ + V(Push_Wide, X, WIDE, xeg, ___, ___) \ + V(Unused12, 0, RESV, ___, ___, ___) \ + V(Unused13, 0, RESV, ___, ___, ___) \ + V(Unused14, 0, RESV, ___, ___, ___) \ + V(Unused15, 0, RESV, ___, ___, ___) \ + V(Unused16, 0, RESV, ___, ___, ___) \ + V(Unused17, 0, RESV, ___, ___, ___) \ + V(PopLocal, X, ORDN, xeg, ___, ___) \ + V(PopLocal_Wide, X, WIDE, xeg, ___, ___) \ + V(LoadStatic, D, ORDN, lit, ___, ___) \ + V(LoadStatic_Wide, D, WIDE, lit, ___, ___) \ + V(StoreLocal, X, ORDN, xeg, ___, ___) \ + V(StoreLocal_Wide, X, WIDE, xeg, ___, ___) \ + V(LoadFieldTOS, D, ORDN, lit, ___, ___) \ + V(LoadFieldTOS_Wide, D, WIDE, lit, ___, ___) \ + V(StoreFieldTOS, D, ORDN, lit, ___, ___) \ + V(StoreFieldTOS_Wide, D, WIDE, lit, ___, ___) \ + V(StoreIndexedTOS, 0, ORDN, ___, ___, ___) \ + V(Unused20, 0, RESV, ___, ___, ___) \ + V(JumpIfInitialized, T, ORDN, tgt, ___, ___) \ + V(JumpIfInitialized_Wide, T, WIDE, tgt, ___, ___) \ + V(PushUninitializedSentinel, 0, ORDN, ___, ___, ___) \ + V(Unused21, 0, RESV, ___, ___, ___) \ + V(InitLateField, D, ORDN, lit, ___, ___) \ + V(InitLateField_Wide, D, WIDE, lit, ___, ___) \ + V(StoreStaticTOS, D, ORDN, lit, ___, ___) \ + V(StoreStaticTOS_Wide, D, WIDE, lit, ___, ___) \ + V(Jump, T, ORDN, tgt, ___, ___) \ + V(Jump_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfNoAsserts, T, ORDN, tgt, ___, ___) \ + V(JumpIfNoAsserts_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfNotZeroTypeArgs, T, ORDN, tgt, ___, ___) \ + V(JumpIfNotZeroTypeArgs_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfEqStrict, T, ORDN, tgt, ___, ___) \ + V(JumpIfEqStrict_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfNeStrict, T, ORDN, tgt, ___, ___) \ + V(JumpIfNeStrict_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfTrue, T, ORDN, tgt, ___, ___) \ + V(JumpIfTrue_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfFalse, T, ORDN, tgt, ___, ___) \ + V(JumpIfFalse_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfNull, T, ORDN, tgt, ___, ___) \ + V(JumpIfNull_Wide, T, WIDE, tgt, ___, ___) \ + V(JumpIfNotNull, T, ORDN, tgt, ___, ___) \ + V(JumpIfNotNull_Wide, T, WIDE, tgt, ___, ___) \ + V(DirectCall, D_F, ORDN, num, num, ___) \ + V(DirectCall_Wide, D_F, WIDE, num, num, ___) \ + V(UncheckedDirectCall, D_F, ORDN, num, num, ___) \ + V(UncheckedDirectCall_Wide, D_F, WIDE, num, num, ___) \ + V(InterfaceCall, D_F, ORDN, num, num, ___) \ + V(InterfaceCall_Wide, D_F, WIDE, num, num, ___) \ + V(Unused23, 0, RESV, ___, ___, ___) \ + V(Unused24, 0, RESV, ___, ___, ___) \ + V(InstantiatedInterfaceCall, D_F, ORDN, num, num, ___) \ + V(InstantiatedInterfaceCall_Wide, D_F, WIDE, num, num, ___) \ + V(UncheckedClosureCall, D_F, ORDN, num, num, ___) \ + V(UncheckedClosureCall_Wide, D_F, WIDE, num, num, ___) \ + V(UncheckedInterfaceCall, D_F, ORDN, num, num, ___) \ + V(UncheckedInterfaceCall_Wide, D_F, WIDE, num, num, ___) \ + V(DynamicCall, D_F, ORDN, num, num, ___) \ + V(DynamicCall_Wide, D_F, WIDE, num, num, ___) \ + V(ReturnTOS, 0, ORDN, ___, ___, ___) \ + V(ReturnAsync, 0, ORDN, ___, ___, ___) \ + V(ReturnAsyncStar, 0, ORDN, ___, ___, ___) \ + V(ReturnSyncStar, 0, ORDN, ___, ___, ___) \ + V(AssertAssignable, A_E, ORDN, num, lit, ___) \ + V(AssertAssignable_Wide, A_E, WIDE, num, lit, ___) \ + V(Unused30, 0, RESV, ___, ___, ___) \ + V(Unused31, 0, RESV, ___, ___, ___) \ + V(AssertBoolean, A, ORDN, num, ___, ___) \ + V(AssertSubtype, 0, ORDN, ___, ___, ___) \ + V(LoadTypeArgumentsField, D, ORDN, lit, ___, ___) \ + V(LoadTypeArgumentsField_Wide, D, WIDE, lit, ___, ___) \ + V(InstantiateType, D, ORDN, lit, ___, ___) \ + V(InstantiateType_Wide, D, WIDE, lit, ___, ___) \ + V(InstantiateTypeArgumentsTOS, A_E, ORDN, num, lit, ___) \ + V(InstantiateTypeArgumentsTOS_Wide, A_E, WIDE, num, lit, ___) \ + V(Unused32, 0, RESV, ___, ___, ___) \ + V(Unused33, 0, RESV, ___, ___, ___) \ + V(Unused34, 0, RESV, ___, ___, ___) \ + V(Unused35, 0, RESV, ___, ___, ___) \ + V(Throw, A, ORDN, num, ___, ___) \ + V(SetFrame, A, ORDN, num, ___, num) \ + V(MoveSpecial, A_Y, ORDN, num, xeg, ___) \ + V(MoveSpecial_Wide, A_Y, WIDE, num, xeg, ___) \ + V(BooleanNegateTOS, 0, ORDN, ___, ___, ___) \ + V(EqualsNull, 0, ORDN, ___, ___, ___) \ + V(NullCheck, D, ORDN, lit, ___, ___) \ + V(NullCheck_Wide, D, WIDE, lit, ___, ___) \ + V(NegateInt, 0, ORDN, ___, ___, ___) \ + V(AddInt, 0, ORDN, ___, ___, ___) \ + V(SubInt, 0, ORDN, ___, ___, ___) \ + V(MulInt, 0, ORDN, ___, ___, ___) \ + V(TruncDivInt, 0, ORDN, ___, ___, ___) \ + V(ModInt, 0, ORDN, ___, ___, ___) \ + V(BitAndInt, 0, ORDN, ___, ___, ___) \ + V(BitOrInt, 0, ORDN, ___, ___, ___) \ + V(BitXorInt, 0, ORDN, ___, ___, ___) \ + V(ShlInt, 0, ORDN, ___, ___, ___) \ + V(ShrInt, 0, ORDN, ___, ___, ___) \ + V(CompareIntEq, 0, ORDN, ___, ___, ___) \ + V(CompareIntGt, 0, ORDN, ___, ___, ___) \ + V(CompareIntLt, 0, ORDN, ___, ___, ___) \ + V(CompareIntGe, 0, ORDN, ___, ___, ___) \ + V(CompareIntLe, 0, ORDN, ___, ___, ___) \ + V(NegateDouble, 0, ORDN, ___, ___, ___) \ + V(AddDouble, 0, ORDN, ___, ___, ___) \ + V(SubDouble, 0, ORDN, ___, ___, ___) \ + V(MulDouble, 0, ORDN, ___, ___, ___) \ + V(DivDouble, 0, ORDN, ___, ___, ___) \ + V(CompareDoubleEq, 0, ORDN, ___, ___, ___) \ + V(CompareDoubleGt, 0, ORDN, ___, ___, ___) \ + V(CompareDoubleLt, 0, ORDN, ___, ___, ___) \ + V(CompareDoubleGe, 0, ORDN, ___, ___, ___) \ + V(CompareDoubleLe, 0, ORDN, ___, ___, ___) \ + + // These bytecodes are only generated within the VM. Reassigning their + // opcodes is not a breaking change. +#define INTERNAL_KERNEL_BYTECODES_LIST(V) \ + V(VMInternal_ImplicitGetter, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ImplicitSetter, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ImplicitStaticGetter, 0, ORDN, ___, ___, ___) \ + V(VMInternal_MethodExtractor, 0, ORDN, ___, ___, ___) \ + V(VMInternal_InvokeClosure, 0, ORDN, ___, ___, ___) \ + V(VMInternal_InvokeField, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ForwardDynamicInvocation, 0, ORDN, ___, ___, ___) \ + V(VMInternal_NoSuchMethodDispatcher, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ImplicitStaticClosure, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ImplicitInstanceClosure, 0, ORDN, ___, ___, ___) \ + V(VMInternal_ImplicitConstructorClosure, 0, ORDN, ___, ___, ___) \ + +#define KERNEL_BYTECODES_LIST(V) \ + PUBLIC_KERNEL_BYTECODES_LIST(V) \ + INTERNAL_KERNEL_BYTECODES_LIST(V) + +// clang-format on + +typedef uint8_t KBCInstr; + +class KernelBytecode { + public: + // Magic value of bytecode files. + static const intptr_t kMagicValue = 0x44424333; // 'DBC3' + // Bytecode format version supported by the VM + // (should match pkg/dart2bytecode/lib/dbc.dart). + static const intptr_t kBytecodeFormatVersion = 1; + + enum Opcode { +#define DECLARE_BYTECODE(name, encoding, kind, op1, op2, op3) k##name, + KERNEL_BYTECODES_LIST(DECLARE_BYTECODE) +#undef DECLARE_BYTECODE + }; + + static const char* NameOf(Opcode op) { + const char* names[] = { +#define NAME(name, encoding, kind, op1, op2, op3) #name, + KERNEL_BYTECODES_LIST(NAME) +#undef NAME + }; + return names[op]; + } + + static const intptr_t kInstructionSize[]; + + enum SpecialIndex { + kExceptionSpecialIndex, + kStackTraceSpecialIndex, + kSpecialIndexCount + }; + + private: + static const intptr_t kWideModifier = 1; + + // Should be used only on instructions with wide variants. + DART_FORCE_INLINE static bool IsWide(const KBCInstr* instr) { + return ((DecodeOpcode(instr) & kWideModifier) != 0); + } + + public: + DART_FORCE_INLINE static uint8_t DecodeA(const KBCInstr* bc) { return bc[1]; } + + DART_FORCE_INLINE static uint8_t DecodeB(const KBCInstr* bc) { return bc[2]; } + + DART_FORCE_INLINE static uint8_t DecodeC(const KBCInstr* bc) { return bc[3]; } + + DART_FORCE_INLINE static uint32_t DecodeD(const KBCInstr* bc) { + if (IsWide(bc)) { + return static_cast(bc[1]) | + (static_cast(bc[2]) << 8) | + (static_cast(bc[3]) << 16) | + (static_cast(bc[4]) << 24); + } else { + return bc[1]; + } + } + + DART_FORCE_INLINE static int32_t DecodeX(const KBCInstr* bc) { + if (IsWide(bc)) { + return static_cast(static_cast(bc[1]) | + (static_cast(bc[2]) << 8) | + (static_cast(bc[3]) << 16) | + (static_cast(bc[4]) << 24)); + } else { + return static_cast(bc[1]); + } + } + + DART_FORCE_INLINE static int32_t DecodeT(const KBCInstr* bc) { + if (IsWide(bc)) { + return static_cast((static_cast(bc[1]) << 8) | + (static_cast(bc[2]) << 16) | + (static_cast(bc[3]) << 24)) >> + 8; + } else { + return static_cast(bc[1]); + } + } + + DART_FORCE_INLINE static uint32_t DecodeE(const KBCInstr* bc) { + if (IsWide(bc)) { + return static_cast(bc[2]) | + (static_cast(bc[3]) << 8) | + (static_cast(bc[4]) << 16) | + (static_cast(bc[5]) << 24); + } else { + return bc[2]; + } + } + + DART_FORCE_INLINE static int32_t DecodeY(const KBCInstr* bc) { + if (IsWide(bc)) { + return static_cast(static_cast(bc[2]) | + (static_cast(bc[3]) << 8) | + (static_cast(bc[4]) << 16) | + (static_cast(bc[5]) << 24)); + } else { + return static_cast(bc[2]); + } + } + + DART_FORCE_INLINE static uint8_t DecodeF(const KBCInstr* bc) { + if (IsWide(bc)) { + return bc[5]; + } else { + return bc[2]; + } + } + + DART_FORCE_INLINE static Opcode DecodeOpcode(const KBCInstr* bc) { + return static_cast(bc[0]); + } + + DART_FORCE_INLINE static const KBCInstr* Next(const KBCInstr* bc) { + return bc + kInstructionSize[DecodeOpcode(bc)]; + } + + DART_FORCE_INLINE static uword Next(uword pc) { + return pc + kInstructionSize[DecodeOpcode( + reinterpret_cast(pc))]; + } + + DART_FORCE_INLINE static bool IsJumpOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kJump: + case KernelBytecode::kJump_Wide: + case KernelBytecode::kJumpIfNoAsserts: + case KernelBytecode::kJumpIfNoAsserts_Wide: + case KernelBytecode::kJumpIfNotZeroTypeArgs: + case KernelBytecode::kJumpIfNotZeroTypeArgs_Wide: + case KernelBytecode::kJumpIfEqStrict: + case KernelBytecode::kJumpIfEqStrict_Wide: + case KernelBytecode::kJumpIfNeStrict: + case KernelBytecode::kJumpIfNeStrict_Wide: + case KernelBytecode::kJumpIfTrue: + case KernelBytecode::kJumpIfTrue_Wide: + case KernelBytecode::kJumpIfFalse: + case KernelBytecode::kJumpIfFalse_Wide: + case KernelBytecode::kJumpIfNull: + case KernelBytecode::kJumpIfNull_Wide: + case KernelBytecode::kJumpIfNotNull: + case KernelBytecode::kJumpIfNotNull_Wide: + case KernelBytecode::kJumpIfUnchecked: + case KernelBytecode::kJumpIfUnchecked_Wide: + case KernelBytecode::kJumpIfInitialized: + case KernelBytecode::kJumpIfInitialized_Wide: + return true; + + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsJumpIfUncheckedOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kJumpIfUnchecked: + case KernelBytecode::kJumpIfUnchecked_Wide: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsLoadConstantOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kLoadConstant: + case KernelBytecode::kLoadConstant_Wide: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsCheckStackOpcode(const KBCInstr* instr) { + return DecodeOpcode(instr) == KernelBytecode::kCheckStack; + } + + DART_FORCE_INLINE static bool IsCheckFunctionTypeArgs(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kCheckFunctionTypeArgs: + case KernelBytecode::kCheckFunctionTypeArgs_Wide: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsEntryOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kEntry: + case KernelBytecode::kEntry_Wide: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsEntryOptionalOpcode(const KBCInstr* instr) { + return DecodeOpcode(instr) == KernelBytecode::kEntryOptional; + } + + DART_FORCE_INLINE static bool IsFrameOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kFrame: + case KernelBytecode::kFrame_Wide: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static bool IsSetFrameOpcode(const KBCInstr* instr) { + return DecodeOpcode(instr) == KernelBytecode::kSetFrame; + } + + DART_FORCE_INLINE static bool IsDebugCheckOpcode(const KBCInstr* instr) { + return DecodeOpcode(instr) == KernelBytecode::kDebugCheck; + } + + // The interpreter, the bytecode generator, the bytecode compiler, and this + // function must agree on this list of opcodes. + // For each instruction with listed opcode: + // - The interpreter checks for a debug break. + // - The bytecode generator emits a source position. + // - The bytecode compiler may emit a DebugStepCheck call. + DART_FORCE_INLINE static bool IsDebugCheckedOpcode(const KBCInstr* instr) { + switch (DecodeOpcode(instr)) { + case KernelBytecode::kDebugCheck: + case KernelBytecode::kDirectCall: + case KernelBytecode::kDirectCall_Wide: + case KernelBytecode::kUncheckedDirectCall: + case KernelBytecode::kUncheckedDirectCall_Wide: + case KernelBytecode::kInterfaceCall: + case KernelBytecode::kInterfaceCall_Wide: + case KernelBytecode::kInstantiatedInterfaceCall: + case KernelBytecode::kInstantiatedInterfaceCall_Wide: + case KernelBytecode::kUncheckedClosureCall: + case KernelBytecode::kUncheckedClosureCall_Wide: + case KernelBytecode::kUncheckedInterfaceCall: + case KernelBytecode::kUncheckedInterfaceCall_Wide: + case KernelBytecode::kDynamicCall: + case KernelBytecode::kDynamicCall_Wide: + case KernelBytecode::kReturnTOS: + case KernelBytecode::kReturnAsync: + case KernelBytecode::kReturnAsyncStar: + case KernelBytecode::kReturnSyncStar: + case KernelBytecode::kEqualsNull: + case KernelBytecode::kNegateInt: + case KernelBytecode::kNegateDouble: + case KernelBytecode::kAddInt: + case KernelBytecode::kSubInt: + case KernelBytecode::kMulInt: + case KernelBytecode::kTruncDivInt: + case KernelBytecode::kModInt: + case KernelBytecode::kBitAndInt: + case KernelBytecode::kBitOrInt: + case KernelBytecode::kBitXorInt: + case KernelBytecode::kShlInt: + case KernelBytecode::kShrInt: + case KernelBytecode::kCompareIntEq: + case KernelBytecode::kCompareIntGt: + case KernelBytecode::kCompareIntLt: + case KernelBytecode::kCompareIntGe: + case KernelBytecode::kCompareIntLe: + case KernelBytecode::kAddDouble: + case KernelBytecode::kSubDouble: + case KernelBytecode::kMulDouble: + case KernelBytecode::kDivDouble: + case KernelBytecode::kCompareDoubleEq: + case KernelBytecode::kCompareDoubleGt: + case KernelBytecode::kCompareDoubleLt: + case KernelBytecode::kCompareDoubleGe: + case KernelBytecode::kCompareDoubleLe: + return true; + default: + return false; + } + } + + DART_FORCE_INLINE static uint8_t DecodeArgc(const KBCInstr* ret_addr) { + // All call instructions have DF encoding, with argc being the last byte + // regardless of whether the wide variant is used or not. + return ret_addr[-1]; + } + + // Converts bytecode PC into an offset. + // For return addresses used in PcDescriptors, PC is also augmented by 1. + // TODO(regis): Eliminate this correction. + static intptr_t BytecodePcToOffset(uint32_t pc, bool is_return_address) { + return pc + (is_return_address ? 1 : 0); + } + + static uint32_t OffsetToBytecodePc(intptr_t offset, bool is_return_address) { + return offset - (is_return_address ? 1 : 0); + } + + static void GetVMInternalBytecodeInstructions(Opcode opcode, + const KBCInstr** instructions, + intptr_t* instructions_size); + + private: + DISALLOW_ALLOCATION(); + DISALLOW_IMPLICIT_CONSTRUCTORS(KernelBytecode); +}; + +} // namespace dart + +#endif // RUNTIME_VM_CONSTANTS_KBC_H_ diff --git a/runtime/vm/dart_entry.cc b/runtime/vm/dart_entry.cc index f60bffed3de..d0ab521d1e3 100644 --- a/runtime/vm/dart_entry.cc +++ b/runtime/vm/dart_entry.cc @@ -9,6 +9,7 @@ #include "vm/debugger.h" #include "vm/dispatch_table.h" #include "vm/heap/safepoint.h" +#include "vm/interpreter.h" #include "vm/object_store.h" #include "vm/resolver.h" #include "vm/runtime_entry.h" @@ -120,6 +121,17 @@ ObjectPtr DartEntry::InvokeFunction(const Function& function, ASSERT(thread->IsDartMutatorThread()); ASSERT(!function.IsNull()); +#if defined(DART_DYNAMIC_MODULES) + if (function.HasBytecode()) { + // SuspendLongJumpScope suspend_long_jump_scope(thread); + TransitionToGenerated transition(thread); + return Interpreter::Current()->Call(function, arguments_descriptor, + arguments, thread); + } else { + ASSERT(!function.is_declared_in_bytecode()); + } +#endif // defined(DART_DYNAMIC_MODULES) + #if !defined(DART_PRECOMPILED_RUNTIME) if (!function.HasCode()) { const Object& result = Object::Handle( diff --git a/runtime/vm/dart_entry.h b/runtime/vm/dart_entry.h index 04a53b109f6..e79688b8878 100644 --- a/runtime/vm/dart_entry.h +++ b/runtime/vm/dart_entry.h @@ -179,6 +179,8 @@ class ArgumentsDescriptor : public ValueObject { // A cache of VM heap allocated arguments descriptors. static ArrayPtr cached_args_descriptors_[kCachedDescriptorCount]; + friend class Interpreter; + friend class InterpreterHelpers; friend class VMSerializationRoots; friend class VMDeserializationRoots; DISALLOW_COPY_AND_ASSIGN(ArgumentsDescriptor); diff --git a/runtime/vm/debugger.cc b/runtime/vm/debugger.cc index 4e273cb4b4f..e01eb5c1a08 100644 --- a/runtime/vm/debugger.cc +++ b/runtime/vm/debugger.cc @@ -1684,7 +1684,7 @@ DebuggerStackTrace* DebuggerStackTrace::Collect() { OS::PrintErr("CollectStackTrace: visiting frame:\n\t%s\n", frame->ToCString()); } - if (frame->IsDartFrame()) { + if (frame->IsDartFrame() && !frame->is_interpreted()) { code = frame->LookupDartCode(); stack_trace->AppendCodeFrames(frame, code); } @@ -1743,6 +1743,9 @@ DebuggerStackTrace* DebuggerStackTrace::CollectAsyncAwaiters() { StackTraceUtils::CollectFrames( thread, /*skip_frames=*/0, [&](const StackTraceUtils::Frame& frame) { + if (frame.code.IsNull()) { + return; + } if (frame.frame != nullptr) { // Synchronous portion of the stack. stack_trace->AppendCodeFrames(frame.frame, frame.code); } else { diff --git a/runtime/vm/exceptions.cc b/runtime/vm/exceptions.cc index 2ca130dcb35..69d963993b3 100644 --- a/runtime/vm/exceptions.cc +++ b/runtime/vm/exceptions.cc @@ -17,6 +17,7 @@ #include "vm/debugger.h" #include "vm/deopt_instructions.h" #include "vm/flags.h" +#include "vm/interpreter.h" #include "vm/log.h" #include "vm/longjump.h" #include "vm/object.h" @@ -105,14 +106,25 @@ static void BuildStackTrace(StackTraceBuilder* builder) { StackFrame* frame = frames.NextFrame(); ASSERT(frame != nullptr); // We expect to find a dart invocation frame. Code& code = Code::Handle(); + Bytecode& bytecode = Bytecode::Handle(); for (; frame != nullptr; frame = frames.NextFrame()) { if (!frame->IsDartFrame()) { continue; } - code = frame->LookupDartCode(); - ASSERT(code.ContainsInstructionAt(frame->pc())); - const uword pc_offset = frame->pc() - code.PayloadStart(); - builder->AddFrame(code, pc_offset); + if (frame->is_interpreted()) { + bytecode = frame->LookupDartBytecode(); + ASSERT(bytecode.ContainsInstructionAt(frame->pc())); + if (bytecode.function() == Function::null()) { + continue; + } + const uword pc_offset = frame->pc() - bytecode.PayloadStart(); + builder->AddFrame(bytecode, pc_offset); + } else { + code = frame->LookupDartCode(); + ASSERT(code.ContainsInstructionAt(frame->pc())); + const uword pc_offset = frame->pc() - code.PayloadStart(); + builder->AddFrame(code, pc_offset); + } } } @@ -587,7 +599,9 @@ static void ClearLazyDeopts(Thread* thread, uword frame_pointer) { StackFrameIterator::kNoCrossThreadIteration); for (StackFrame* frame = frames.NextFrame(); frame != nullptr; frame = frames.NextFrame()) { - if (frame->fp() >= frame_pointer) { + if (frame->is_interpreted()) { + continue; + } else if (frame->fp() >= frame_pointer) { break; } if (frame->IsMarkedForLazyDeopt()) { @@ -634,6 +648,15 @@ NO_SANITIZE_SAFE_STACK // This function manipulates the safestack pointer. uword frame_pointer, bool clear_deopt_at_target) { ASSERT(thread->execution_state() == Thread::kThreadInVM); + +#if defined(DART_DYNAMIC_MODULES) + Interpreter* interpreter = thread->interpreter(); + if ((interpreter != nullptr) && interpreter->HasFrame(frame_pointer)) { + interpreter->JumpToFrame(program_counter, stack_pointer, frame_pointer, + thread); + } +#endif // defined(DART_DYNAMIC_MODULES) + const uword fp_for_clearing = (clear_deopt_at_target ? frame_pointer + 1 : frame_pointer); ClearLazyDeopts(thread, fp_for_clearing); diff --git a/runtime/vm/gdb_helpers.cc b/runtime/vm/gdb_helpers.cc index 79da2b5c81f..8cf64bf5a4d 100644 --- a/runtime/vm/gdb_helpers.cc +++ b/runtime/vm/gdb_helpers.cc @@ -87,6 +87,28 @@ void _printGeneratedStackTrace(uword fp, uword sp, uword pc) { } } +#if defined(DART_DYNAMIC_MODULES) +// Like _printDartStackTrace, but works in the interpreter loop. +// Must be called with the current interpreter fp, sp, and pc. +// Note that sp[0] is not modified, but sp[1] will be trashed. +DART_EXPORT +void _printInterpreterStackTrace(ObjectPtr* fp, + ObjectPtr* sp, + const KBCInstr* pc) { + Thread* thread = Thread::Current(); + sp[1] = Function::null(); + sp[2] = Bytecode::null(); + sp[3] = static_cast(reinterpret_cast(pc)); + sp[4] = static_cast(reinterpret_cast(fp)); + ObjectPtr* exit_fp = sp + 1 + kKBCDartFrameFixedSize; + thread->set_top_exit_frame_info(reinterpret_cast(exit_fp)); + thread->set_execution_state(Thread::kThreadInVM); + _printDartStackTrace(); + thread->set_execution_state(Thread::kThreadInGenerated); + thread->set_top_exit_frame_info(0); +} +#endif // defined(DART_DYNAMIC_MODULES) + class PrintObjectPointersVisitor : public ObjectPointerVisitor { public: PrintObjectPointersVisitor() diff --git a/runtime/vm/heap/marker.cc b/runtime/vm/heap/marker.cc index 4435c0693d0..c7a784248bb 100644 --- a/runtime/vm/heap/marker.cc +++ b/runtime/vm/heap/marker.cc @@ -726,6 +726,20 @@ class MarkingWeakVisitor : public HandleVisitor { void GCMarker::Prologue() { isolate_group_->ReleaseStoreBuffers(); new_marking_stack_.PushAll(tlab_deferred_marking_stack_.PopAll()); + +#if defined(DART_DYNAMIC_MODULES) + isolate_group_->ForEachIsolate( + [&](Isolate* isolate) { + Thread* mutator_thread = isolate->mutator_thread(); + if (mutator_thread != nullptr) { + Interpreter* interpreter = mutator_thread->interpreter(); + if (interpreter != nullptr) { + interpreter->ClearLookupCache(); + } + } + }, + /*at_safepoint=*/true); +#endif // defined(DART_DYNAMIC_MODULES) } void GCMarker::Epilogue() {} diff --git a/runtime/vm/interpreter.cc b/runtime/vm/interpreter.cc new file mode 100644 index 00000000000..fb16c972c5e --- /dev/null +++ b/runtime/vm/interpreter.cc @@ -0,0 +1,3650 @@ +// Copyright (c) 2024, 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 // NOLINT +#include + +#include "vm/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/interpreter.h" + +#include "vm/bytecode_reader.h" +#include "vm/class_id.h" +#include "vm/compiler/api/type_check_mode.h" +#include "vm/compiler/assembler/disassembler_kbc.h" +#include "vm/cpu.h" +#include "vm/dart_entry.h" +#include "vm/debugger.h" +#include "vm/lockers.h" +#include "vm/native_arguments.h" +#include "vm/native_entry.h" +#include "vm/object.h" +#include "vm/object_store.h" +#include "vm/os_thread.h" +#include "vm/stack_frame_kbc.h" +#include "vm/symbols.h" + +namespace dart { + +DEFINE_FLAG(uint64_t, + trace_interpreter_after, + ULLONG_MAX, + "Trace interpreter execution after instruction count reached."); +DEFINE_FLAG(charp, + interpreter_trace_file, + NULL, + "File to write a dynamic instruction trace to."); +DEFINE_FLAG(uint64_t, + interpreter_trace_file_max_bytes, + 100 * MB, + "Maximum size in bytes of the interpreter trace file"); + +// InterpreterSetjmpBuffer are linked together, and the last created one +// is referenced by the Interpreter. When an exception is thrown, the exception +// runtime looks at where to jump and finds the corresponding +// InterpreterSetjmpBuffer based on the stack pointer of the exception handler. +// The runtime then does a Longjmp on that buffer to return to the interpreter. +class InterpreterSetjmpBuffer { + public: + void Longjmp() { + // "This" is now the last setjmp buffer. + interpreter_->set_last_setjmp_buffer(this); + longjmp(buffer_, 1); + } + + explicit InterpreterSetjmpBuffer(Interpreter* interpreter) { + interpreter_ = interpreter; + link_ = interpreter->last_setjmp_buffer(); + interpreter->set_last_setjmp_buffer(this); + fp_ = interpreter->fp_; + } + + ~InterpreterSetjmpBuffer() { + ASSERT(interpreter_->last_setjmp_buffer() == this); + interpreter_->set_last_setjmp_buffer(link_); + } + + InterpreterSetjmpBuffer* link() const { return link_; } + + uword fp() const { return reinterpret_cast(fp_); } + + jmp_buf buffer_; + + private: + ObjectPtr* fp_; + Interpreter* interpreter_; + InterpreterSetjmpBuffer* link_; + + friend class Interpreter; + + DISALLOW_ALLOCATION(); + DISALLOW_COPY_AND_ASSIGN(InterpreterSetjmpBuffer); +}; + +DART_FORCE_INLINE static ObjectPtr* SavedCallerFP(ObjectPtr* FP) { + return reinterpret_cast( + static_cast(FP[kKBCSavedCallerFpSlotFromFp])); +} + +DART_FORCE_INLINE static ObjectPtr* FrameArguments(ObjectPtr* FP, + intptr_t argc) { + return FP - (kKBCDartFrameFixedSize + argc); +} + +#define RAW_CAST(Type, val) (InterpreterHelpers::CastTo##Type(val)) + +class InterpreterHelpers { + public: +#define DEFINE_CASTS(Type) \ + DART_FORCE_INLINE static Type##Ptr CastTo##Type(ObjectPtr obj) { \ + ASSERT((k##Type##Cid == kSmiCid) ? !obj->IsHeapObject() \ + : (k##Type##Cid == kIntegerCid) \ + ? (!obj->IsHeapObject() || obj->IsMint()) \ + : obj->Is##Type()); \ + return static_cast(obj); \ + } + CLASS_LIST(DEFINE_CASTS) +#undef DEFINE_CASTS + + DART_FORCE_INLINE static SmiPtr GetClassIdAsSmi(ObjectPtr obj) { + return Smi::New(obj->IsHeapObject() ? obj->GetClassId() + : static_cast(kSmiCid)); + } + + DART_FORCE_INLINE static intptr_t GetClassId(ObjectPtr obj) { + return obj->IsHeapObject() ? obj->GetClassId() + : static_cast(kSmiCid); + } + + template + DART_FORCE_INLINE static type GetField(ObjectPtr obj, + intptr_t offset_in_words) { + return obj->untag()->LoadCompressedPointer( + reinterpret_cast( + static_cast(obj) - kHeapObjectTag + + offset_in_words * kCompressedWordSize)); + } + DART_FORCE_INLINE static void SetField(ObjectPtr obj, + intptr_t offset_in_words, + ObjectPtr value, + Thread* thread) { + obj->untag()->StoreCompressedPointer( + reinterpret_cast( + static_cast(obj) - kHeapObjectTag + + offset_in_words * kCompressedWordSize), + value, thread); + } + +#define GET_FIELD_T(type, obj, offset_in_words) \ + InterpreterHelpers::GetField(obj, offset_in_words) +#define GET_FIELD(obj, offset_in_words) \ + GET_FIELD_T(ObjectPtr, obj, offset_in_words) + + DART_FORCE_INLINE static TypeArgumentsPtr GetTypeArguments( + Thread* thread, + InstancePtr instance) { + ClassPtr instance_class = + thread->isolate_group()->class_table()->At(GetClassId(instance)); + return instance_class->untag()->num_type_arguments_ > 0 + ? GET_FIELD_T(TypeArgumentsPtr, instance, + instance_class->untag() + ->host_type_arguments_field_offset_in_words_) + : TypeArguments::null(); + } + + // The usage counter is actually a 'hotness' counter. + // For an instance call, both the usage counters of the caller and of the + // calle will get incremented, as well as the ICdata counter at the call site. + DART_FORCE_INLINE static void IncrementUsageCounter(FunctionPtr f) { +#if !defined(DART_PRECOMPILED_RUNTIME) + f->untag()->usage_counter_++; +#endif + } + + DART_FORCE_INLINE static void IncrementICUsageCount(ObjectPtr* entries, + intptr_t offset, + intptr_t args_tested) { + const intptr_t count_offset = ICData::CountIndexFor(args_tested); + const intptr_t raw_smi_old = + static_cast(entries[offset + count_offset]); + const intptr_t raw_smi_new = raw_smi_old + Smi::RawValue(1); + *reinterpret_cast(&entries[offset + count_offset]) = raw_smi_new; + } + + DART_FORCE_INLINE static bool CheckIndex(SmiPtr index, SmiPtr length) { + return !index->IsHeapObject() && (static_cast(index) >= 0) && + (static_cast(index) < static_cast(length)); + } + + DART_FORCE_INLINE static intptr_t ArgDescTypeArgsLen(ArrayPtr argdesc) { + return Smi::Value(Smi::RawCast( + argdesc->untag()->element(ArgumentsDescriptor::kTypeArgsLenIndex))); + } + + DART_FORCE_INLINE static intptr_t ArgDescArgCount(ArrayPtr argdesc) { + return Smi::Value(Smi::RawCast( + argdesc->untag()->element(ArgumentsDescriptor::kCountIndex))); + } + + DART_FORCE_INLINE static intptr_t ArgDescArgSize(ArrayPtr argdesc) { + return Smi::Value(Smi::RawCast( + argdesc->untag()->element(ArgumentsDescriptor::kSizeIndex))); + } + + DART_FORCE_INLINE static intptr_t ArgDescPosCount(ArrayPtr argdesc) { + return Smi::Value(Smi::RawCast( + argdesc->untag()->element(ArgumentsDescriptor::kPositionalCountIndex))); + } + + DART_FORCE_INLINE static BytecodePtr FrameBytecode(ObjectPtr* FP) { + ASSERT(GetClassId(FP[kKBCPcMarkerSlotFromFp]) == kBytecodeCid); + return static_cast(FP[kKBCPcMarkerSlotFromFp]); + } + + DART_FORCE_INLINE static bool FieldNeedsGuardUpdate(Thread* thread, + FieldPtr field, + ObjectPtr value) { + if (!thread->isolate_group()->use_field_guards()) { + return false; + } + + // The interpreter should never see a cloned field. + ASSERT(field->untag()->owner()->GetClassId() != kFieldCid); + + const classid_t guarded_cid = field->untag()->guarded_cid_; + + if (guarded_cid == kDynamicCid) { + // Field is not guarded. + return false; + } + + const classid_t nullability_cid = field->untag()->is_nullable_; + const classid_t value_cid = InterpreterHelpers::GetClassId(value); + + if (nullability_cid == value_cid) { + // Storing null into a nullable field. + return false; + } + + if (guarded_cid != value_cid) { + // First assignment (guarded_cid == kIllegalCid) or + // field no longer monomorphic or + // field has become nullable. + return true; + } + + intptr_t guarded_list_length = + Smi::Value(field->untag()->guarded_list_length()); + + if (UNLIKELY(guarded_list_length >= Field::kUnknownFixedLength)) { + // Guarding length, check this in the runtime. + return true; + } + + if (UNLIKELY(field->untag()->static_type_exactness_state_ >= + StaticTypeExactnessState::Uninitialized().Encode())) { + // Guarding "exactness", check this in the runtime. + return true; + } + + // Everything matches. + return false; + } + + DART_FORCE_INLINE static bool IsAllocateFinalized(ClassPtr cls) { + return Class::ClassFinalizedBits::decode(cls->untag()->state_bits_) == + UntaggedClass::kAllocateFinalized; + } +}; + +DART_FORCE_INLINE static const KBCInstr* SavedCallerPC(ObjectPtr* FP) { + return reinterpret_cast( + static_cast(FP[kKBCSavedCallerPcSlotFromFp])); +} + +DART_FORCE_INLINE static FunctionPtr FrameFunction(ObjectPtr* FP) { + FunctionPtr function = static_cast(FP[kKBCFunctionSlotFromFp]); + ASSERT(InterpreterHelpers::GetClassId(function) == kFunctionCid || + InterpreterHelpers::GetClassId(function) == kNullCid); + return function; +} + +DART_FORCE_INLINE static ObjectPtr InitializeHeader(uword addr, + intptr_t class_id, + intptr_t instance_size) { + uint32_t tags = 0; + ASSERT(class_id != kIllegalCid); + tags = UntaggedObject::ClassIdTag::update(class_id, tags); + tags = UntaggedObject::SizeTag::update(instance_size, tags); + const bool is_old = false; + tags = UntaggedObject::AlwaysSetBit::update(true, tags); + tags = UntaggedObject::NotMarkedBit::update(true, tags); + tags = UntaggedObject::OldAndNotRememberedBit::update(is_old, tags); + tags = UntaggedObject::NewOrEvacuationCandidateBit::update(!is_old, tags); + tags = UntaggedObject::ImmutableBit::update( + Object::ShouldHaveImmutabilityBitSet(class_id), tags); +#if defined(HASH_IN_OBJECT_HEADER) + tags = UntaggedObject::HashTag::update(0, tags); +#endif + // Also writes zero in the hash_ field. + *reinterpret_cast(addr + Object::tags_offset()) = tags; + return UntaggedObject::FromAddr(addr); +} + +DART_FORCE_INLINE static bool TryAllocate(Thread* thread, + intptr_t class_id, + intptr_t instance_size, + ObjectPtr* result) { + ASSERT(instance_size > 0); + ASSERT(Utils::IsAligned(instance_size, kObjectAlignment)); + + const uword top = thread->top(); + const intptr_t remaining = thread->end() - top; + if (LIKELY(remaining >= instance_size)) { + thread->set_top(top + instance_size); + *result = InitializeHeader(top, class_id, instance_size); + return true; + } + return false; +} + +void LookupCache::Clear() { + for (intptr_t i = 0; i < kNumEntries; i++) { + entries_[i].receiver_cid = kIllegalCid; + } +} + +bool LookupCache::Lookup(intptr_t receiver_cid, + StringPtr function_name, + ArrayPtr arguments_descriptor, + FunctionPtr* target) const { + ASSERT(receiver_cid != kIllegalCid); // Sentinel value. + + const intptr_t hash = receiver_cid ^ static_cast(function_name) ^ + static_cast(arguments_descriptor); + const intptr_t probe1 = hash & kTableMask; + if (entries_[probe1].receiver_cid == receiver_cid && + entries_[probe1].function_name == function_name && + entries_[probe1].arguments_descriptor == arguments_descriptor) { + *target = entries_[probe1].target; + return true; + } + + intptr_t probe2 = (hash >> 3) & kTableMask; + if (entries_[probe2].receiver_cid == receiver_cid && + entries_[probe2].function_name == function_name && + entries_[probe2].arguments_descriptor == arguments_descriptor) { + *target = entries_[probe2].target; + return true; + } + + return false; +} + +void LookupCache::Insert(intptr_t receiver_cid, + StringPtr function_name, + ArrayPtr arguments_descriptor, + FunctionPtr target) { + // Otherwise we have to clear the cache or rehash on scavenges too. + ASSERT(function_name->IsOldObject()); + ASSERT(arguments_descriptor->IsOldObject()); + ASSERT(target->IsOldObject()); + + const intptr_t hash = receiver_cid ^ static_cast(function_name) ^ + static_cast(arguments_descriptor); + const intptr_t probe1 = hash & kTableMask; + if (entries_[probe1].receiver_cid == kIllegalCid) { + entries_[probe1].receiver_cid = receiver_cid; + entries_[probe1].function_name = function_name; + entries_[probe1].arguments_descriptor = arguments_descriptor; + entries_[probe1].target = target; + return; + } + + const intptr_t probe2 = (hash >> 3) & kTableMask; + if (entries_[probe2].receiver_cid == kIllegalCid) { + entries_[probe2].receiver_cid = receiver_cid; + entries_[probe2].function_name = function_name; + entries_[probe2].arguments_descriptor = arguments_descriptor; + entries_[probe2].target = target; + return; + } + + entries_[probe1].receiver_cid = receiver_cid; + entries_[probe1].function_name = function_name; + entries_[probe1].arguments_descriptor = arguments_descriptor; + entries_[probe1].target = target; +} + +Interpreter::Interpreter() + : stack_(NULL), + fp_(NULL), + pp_(nullptr), + argdesc_(nullptr), + lookup_cache_() { + // Setup interpreter support first. Some of this information is needed to + // setup the architecture state. + // We allocate the stack here, the size is computed as the sum of + // the size specified by the user and the buffer space needed for + // handling stack overflow exceptions. To be safe in potential + // stack underflows we also add some underflow buffer space. + stack_ = new uintptr_t[(OSThread::GetSpecifiedStackSize() + + OSThread::kStackSizeBufferMax + + kInterpreterStackUnderflowSize) / + sizeof(uintptr_t)]; + // Low address. + stack_base_ = + reinterpret_cast(stack_) + kInterpreterStackUnderflowSize; + // Limit for StackOverflowError. + overflow_stack_limit_ = stack_base_ + OSThread::GetSpecifiedStackSize(); + // High address. + stack_limit_ = overflow_stack_limit_ + OSThread::kStackSizeBufferMax; + + last_setjmp_buffer_ = NULL; + + DEBUG_ONLY(icount_ = 1); // So that tracing after 0 traces first bytecode. + +#if defined(DEBUG) + trace_file_bytes_written_ = 0; + trace_file_ = NULL; + if (FLAG_interpreter_trace_file != NULL) { + Dart_FileOpenCallback file_open = Dart::file_open_callback(); + if (file_open != NULL) { + trace_file_ = file_open(FLAG_interpreter_trace_file, /* write */ true); + trace_buffer_ = new KBCInstr[kTraceBufferInstrs]; + trace_buffer_idx_ = 0; + } + } +#endif +} + +Interpreter::~Interpreter() { + delete[] stack_; + pp_ = NULL; + argdesc_ = NULL; +#if defined(DEBUG) + if (trace_file_ != NULL) { + FlushTraceBuffer(); + // Close the file. + Dart_FileCloseCallback file_close = Dart::file_close_callback(); + if (file_close != NULL) { + file_close(trace_file_); + trace_file_ = NULL; + delete[] trace_buffer_; + trace_buffer_ = NULL; + } + } +#endif +} + +// Get the active Interpreter for the current isolate. +Interpreter* Interpreter::Current() { + Thread* thread = Thread::Current(); + Interpreter* interpreter = thread->interpreter(); + if (interpreter == nullptr) { + NoSafepointScope no_safepoint; + interpreter = new Interpreter(); + thread->set_interpreter(interpreter); + } + return interpreter; +} + +#if defined(DEBUG) +// Returns true if tracing of executed instructions is enabled. +// May be called on entry, when icount_ has not been incremented yet. +DART_FORCE_INLINE bool Interpreter::IsTracingExecution() const { + return icount_ > FLAG_trace_interpreter_after; +} + +// Prints bytecode instruction at given pc for instruction tracing. +DART_NOINLINE void Interpreter::TraceInstruction(const KBCInstr* pc) const { + THR_Print("%" Pu64 " ", icount_); + if (FLAG_support_disassembler) { + KernelBytecodeDisassembler::Disassemble( + reinterpret_cast(pc), + reinterpret_cast(KernelBytecode::Next(pc))); + } else { + THR_Print("Disassembler not supported in this mode.\n"); + } +} + +DART_FORCE_INLINE bool Interpreter::IsWritingTraceFile() const { + return (trace_file_ != NULL) && + (trace_file_bytes_written_ < FLAG_interpreter_trace_file_max_bytes); +} + +void Interpreter::FlushTraceBuffer() { + Dart_FileWriteCallback file_write = Dart::file_write_callback(); + if (file_write == NULL) { + return; + } + if (trace_file_bytes_written_ >= FLAG_interpreter_trace_file_max_bytes) { + return; + } + const intptr_t bytes_to_write = Utils::Minimum( + static_cast(trace_buffer_idx_ * sizeof(KBCInstr)), + FLAG_interpreter_trace_file_max_bytes - trace_file_bytes_written_); + if (bytes_to_write == 0) { + return; + } + file_write(trace_buffer_, bytes_to_write, trace_file_); + trace_file_bytes_written_ += bytes_to_write; + trace_buffer_idx_ = 0; +} + +DART_NOINLINE void Interpreter::WriteInstructionToTrace(const KBCInstr* pc) { + Dart_FileWriteCallback file_write = Dart::file_write_callback(); + if (file_write == NULL) { + return; + } + const KBCInstr* next = KernelBytecode::Next(pc); + while ((trace_buffer_idx_ < kTraceBufferInstrs) && (pc != next)) { + trace_buffer_[trace_buffer_idx_++] = *pc; + ++pc; + } + if (trace_buffer_idx_ == kTraceBufferInstrs) { + FlushTraceBuffer(); + } +} + +#endif // defined(DEBUG) + +// Calls into the Dart runtime are based on this interface. +typedef void (*InterpreterRuntimeCall)(NativeArguments arguments); + +// Calls to leaf Dart runtime functions are based on this interface. +typedef intptr_t (*InterpreterLeafRuntimeCall)(intptr_t r0, + intptr_t r1, + intptr_t r2, + intptr_t r3); + +// Calls to leaf float Dart runtime functions are based on this interface. +typedef double (*InterpreterLeafFloatRuntimeCall)(double d0, double d1); + +void Interpreter::Exit(Thread* thread, + ObjectPtr* base, + ObjectPtr* frame, + const KBCInstr* pc) { + frame[0] = Function::null(); + frame[1] = Bytecode::null(); + frame[2] = static_cast(reinterpret_cast(pc)); + frame[3] = static_cast(reinterpret_cast(base)); + + ObjectPtr* exit_fp = frame + kKBCDartFrameFixedSize; + thread->set_top_exit_frame_info(reinterpret_cast(exit_fp)); + fp_ = exit_fp; + +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("Exiting interpreter 0x%" Px " at fp_ 0x%" Px "\n", + reinterpret_cast(this), reinterpret_cast(exit_fp)); + } +#endif +} + +void Interpreter::Unexit(Thread* thread) { +#if !defined(PRODUCT) + // For the profiler. + ObjectPtr* exit_fp = + reinterpret_cast(thread->top_exit_frame_info()); + ASSERT(exit_fp != 0); + pc_ = SavedCallerPC(exit_fp); + fp_ = SavedCallerFP(exit_fp); +#endif + thread->set_top_exit_frame_info(0); +} + +// Calling into runtime may trigger garbage collection and relocate objects, +// so all ObjectPtr pointers become outdated and should not be used across +// runtime calls. +// Note: functions below are marked DART_NOINLINE to recover performance where +// inlining these functions into the interpreter loop seemed to cause some code +// quality issues. Functions with the "returns_twice" attribute, such as setjmp, +// prevent reusing spill slots and large frame sizes. +static DART_NOINLINE bool InvokeRuntime(Thread* thread, + Interpreter* interpreter, + RuntimeFunction drt, + const NativeArguments& args) { + InterpreterSetjmpBuffer buffer(interpreter); + if (!setjmp(buffer.buffer_)) { + thread->set_vm_tag(reinterpret_cast(drt)); + drt(args); + thread->set_vm_tag(VMTag::kDartInterpretedTagId); + interpreter->Unexit(thread); + return true; + } else { + return false; + } +} + +extern "C" { +// Note: The invocation stub follows the C ABI, so we cannot pass C++ struct +// values like ObjectPtr. In some calling conventions (IA32), ObjectPtr is +// passed/returned different from a pointer. +typedef uword /*ObjectPtr*/ (*invokestub)( +#if defined(DART_PRECOMPILED_RUNTIME) + uword entry_point, +#else + uword /*CodePtr*/ target_code, +#endif + uword /*ArrayPtr*/ argdesc, + ObjectPtr* arg0, + Thread* thread); +} + +DART_NOINLINE bool Interpreter::InvokeCompiled(Thread* thread, + FunctionPtr function, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP) { + ASSERT(Function::HasCode(function)); + ASSERT(function->untag()->code() != StubCode::LazyCompile().ptr()); + // TODO(regis): Once we share the same stack, try to invoke directly. +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("invoking compiled %s\n", Function::Handle(function).ToCString()); + } +#endif + // On success, returns a RawInstance. On failure, a RawError. + invokestub volatile entrypoint = reinterpret_cast( + StubCode::InvokeDartCodeFromBytecode().EntryPoint()); + ObjectPtr result; + Exit(thread, *FP, call_top + 1, *pc); + { + InterpreterSetjmpBuffer buffer(this); + if (!setjmp(buffer.buffer_)) { +#if defined(USING_SIMULATOR) + // We need to beware that bouncing between the interpreter and the + // simulator may exhaust the C stack before exhausting either the + // interpreter or simulator stacks. + if (!thread->os_thread()->HasStackHeadroom()) { + thread->SetStackLimit(-1); + } + result = bit_copy(Simulator::Current()->Call( + reinterpret_cast(entrypoint), +#if defined(DART_PRECOMPILED_RUNTIME) + static_cast(function->untag()->entry_point_), +#else + static_cast(function->untag()->code()), +#endif + static_cast(argdesc_), + reinterpret_cast(call_base), + reinterpret_cast(thread))); +#else + result = static_cast(entrypoint( +#if defined(DART_PRECOMPILED_RUNTIME) + function->untag()->entry_point_, +#else + static_cast(function->untag()->code()), +#endif + static_cast(argdesc_), call_base, thread)); +#endif + ASSERT(thread->vm_tag() == VMTag::kDartInterpretedTagId); + ASSERT(thread->execution_state() == Thread::kThreadInGenerated); + Unexit(thread); + } else { + return false; + } + } + // Pop args and push result. + *SP = call_base; + **SP = result; + pp_ = InterpreterHelpers::FrameBytecode(*FP)->untag()->object_pool(); + + // If the result is an error (not a Dart instance), it must either be rethrown + // (in the case of an unhandled exception) or it must be returned to the + // caller of the interpreter to be propagated. + if (result->IsHeapObject()) { + const intptr_t result_cid = result->GetClassId(); + if (result_cid == kUnhandledExceptionCid) { + (*SP)[0] = UnhandledException::RawCast(result)->untag()->exception(); + (*SP)[1] = UnhandledException::RawCast(result)->untag()->stacktrace(); + (*SP)[2] = 0; // Do not bypass debugger. + (*SP)[3] = 0; // Space for result. + Exit(thread, *FP, *SP + 4, *pc); + NativeArguments args(thread, 3, *SP, *SP + 3); + if (!InvokeRuntime(thread, this, DRT_ReThrow, args)) { + return false; + } + UNREACHABLE(); + } + if (IsErrorClassId(result_cid)) { + // Unwind to entry frame. + fp_ = *FP; + pc_ = SavedCallerPC(fp_); + while (!IsEntryFrameMarker(pc_)) { + fp_ = SavedCallerFP(fp_); + pc_ = SavedCallerPC(fp_); + } + // Pop entry frame. + fp_ = SavedCallerFP(fp_); + special_[KernelBytecode::kExceptionSpecialIndex] = result; + return false; + } + } + return true; +} + +DART_FORCE_INLINE bool Interpreter::InvokeBytecode(Thread* thread, + FunctionPtr function, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP) { + ASSERT(Function::HasBytecode(function)); +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("invoking %s\n", + Function::Handle(function).ToFullyQualifiedCString()); + } +#endif + ObjectPtr* callee_fp = call_top + kKBCDartFrameFixedSize; + ASSERT(function == FrameFunction(callee_fp)); + BytecodePtr bytecode = Function::GetBytecode(function); + callee_fp[kKBCPcMarkerSlotFromFp] = bytecode; + callee_fp[kKBCSavedCallerPcSlotFromFp] = + static_cast(reinterpret_cast(*pc)); + callee_fp[kKBCSavedCallerFpSlotFromFp] = + static_cast(reinterpret_cast(*FP)); + pp_ = bytecode->untag()->object_pool(); + *pc = reinterpret_cast(bytecode->untag()->instructions_); + NOT_IN_PRODUCT(pc_ = *pc); // For the profiler. + *FP = callee_fp; + NOT_IN_PRODUCT(fp_ = callee_fp); // For the profiler. + *SP = *FP - 1; + return true; +} + +DART_FORCE_INLINE bool Interpreter::Invoke(Thread* thread, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP) { + ObjectPtr* callee_fp = call_top + kKBCDartFrameFixedSize; + FunctionPtr function = FrameFunction(callee_fp); + + for (;;) { + if (Function::HasBytecode(function)) { + return InvokeBytecode(thread, function, call_base, call_top, pc, FP, SP); + } else if (Function::HasCode(function)) { + return InvokeCompiled(thread, function, call_base, call_top, pc, FP, SP); + } + + // Compile the function to either generate code or load bytecode. + call_top[1] = 0; // Code result. + call_top[2] = function; + Exit(thread, *FP, call_top + 3, *pc); + NativeArguments native_args(thread, 1, call_top + 2, call_top + 1); + if (!InvokeRuntime(thread, this, DRT_CompileFunction, native_args)) { + return false; + } + // Reload objects after the call which may trigger GC. + function = Function::RawCast(call_top[2]); + + ASSERT(Function::HasCode(function)); + } +} + +DART_FORCE_INLINE bool Interpreter::InstanceCall(Thread* thread, + StringPtr target_name, + ObjectPtr* call_base, + ObjectPtr* top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP) { + ObjectPtr null_value = Object::null(); + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + + intptr_t receiver_cid = + InterpreterHelpers::GetClassId(call_base[receiver_idx]); + + FunctionPtr target; + if (UNLIKELY(!lookup_cache_.Lookup(receiver_cid, target_name, argdesc_, + &target))) { + // Table lookup miss. + top[0] = null_value; // Clean up slot as it may be visited by GC. + top[1] = call_base[receiver_idx]; + top[2] = target_name; + top[3] = argdesc_; + top[4] = null_value; // Result slot. + + Exit(thread, *FP, top + 5, *pc); + NativeArguments native_args(thread, 3, /* argv */ top + 1, + /* result */ top + 4); + if (!InvokeRuntime(thread, this, DRT_InterpretedInstanceCallMissHandler, + native_args)) { + return false; + } + + target = static_cast(top[4]); + target_name = static_cast(top[2]); + argdesc_ = static_cast(top[3]); + } + + if (target != Function::null()) { + lookup_cache_.Insert(receiver_cid, target_name, argdesc_, target); + top[0] = target; + return Invoke(thread, call_base, top, pc, FP, SP); + } + + // The miss handler should only fail to return a function in AOT mode, + // in which case we need to call DRT_InvokeNoSuchMethod, which + // walks the receiver appropriately in this case. +#if defined(DART_PRECOMPILED_RUNTIME) + + // The receiver, name, and argument descriptor are already in the appropriate + // places on the stack from the previous call. + ASSERT(top[4] == null_value); + + // Allocate array of arguments. + { + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ASSERT_EQUAL(top - call_base, argc); + + top[5] = Smi::New(argc); // length + top[6] = null_value; // type + Exit(thread, *FP, top + 7, *pc); + NativeArguments native_args(thread, 2, /* argv */ top + 5, + /* result */ top + 4); + if (!InvokeRuntime(thread, this, DRT_AllocateArray, native_args)) { + return false; + } + + // Copy arguments into the newly allocated array. + ArrayPtr array = Array::RawCast(top[4]); + for (intptr_t i = 0; i < argc; i++) { + array->untag()->set_element(i, call_base[i], thread); + } + } + + { + Exit(thread, *FP, top + 5, *pc); + NativeArguments native_args(thread, 4, /* argv */ top + 1, + /* result */ top); + if (!InvokeRuntime(thread, this, DRT_InvokeNoSuchMethod, native_args)) { + return false; + } + + // Pop the call args and push the result. + ObjectPtr result = top[0]; + *SP = call_base; + **SP = result; + pp_ = InterpreterHelpers::FrameBytecode(*FP)->untag()->object_pool(); + } +#else + UNREACHABLE(); +#endif + + return true; +} + +// Note: +// All macro helpers are intended to be used only inside Interpreter::Call. + +// Counts and prints executed bytecode instructions (in DEBUG mode). +#if defined(DEBUG) +#define TRACE_INSTRUCTION \ + if (IsTracingExecution()) { \ + TraceInstruction(pc); \ + } \ + if (IsWritingTraceFile()) { \ + WriteInstructionToTrace(pc); \ + } \ + icount_++; +#else +#define TRACE_INSTRUCTION +#endif // defined(DEBUG) + +// Decode opcode and A part of the given value and dispatch to the +// corresponding bytecode handler. +#ifdef DART_HAS_COMPUTED_GOTO +#define DISPATCH_OP(val) \ + do { \ + op = (val); \ + TRACE_INSTRUCTION \ + goto* dispatch[op]; \ + } while (0) +#else +#define DISPATCH_OP(val) \ + do { \ + op = (val); \ + TRACE_INSTRUCTION \ + goto SwitchDispatch; \ + } while (0) +#endif + +// Fetch next operation from PC and dispatch. +#define DISPATCH() DISPATCH_OP(*pc) + +// Load target of a jump instruction into PC. +#define LOAD_JUMP_TARGET() pc = rT + +#define BYTECODE_ENTRY_LABEL(Name) bc##Name: +#define BYTECODE_WIDE_ENTRY_LABEL(Name) bc##Name##_Wide: +#define BYTECODE_IMPL_LABEL(Name) bc##Name##Impl: +#define GOTO_BYTECODE_IMPL(Name) goto bc##Name##Impl; + +// Define entry point that handles bytecode Name with the given operand format. +#define BYTECODE(Name, Operands) BYTECODE_HEADER_##Operands(Name) + +// Helpers to decode common instruction formats. Used in conjunction with +// BYTECODE() macro. + +#define BYTECODE_HEADER_0(Name) \ + BYTECODE_ENTRY_LABEL(Name) \ + pc += 1; + +#define BYTECODE_HEADER_A(Name) \ + uint32_t rA; \ + USE(rA); \ + BYTECODE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + pc += 2; + +#define BYTECODE_HEADER_D(Name) \ + uint32_t rD; \ + USE(rD); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rD = static_cast(pc[1]) | (static_cast(pc[2]) << 8) | \ + (static_cast(pc[3]) << 16) | \ + (static_cast(pc[4]) << 24); \ + pc += 5; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rD = pc[1]; \ + pc += 2; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_X(Name) \ + int32_t rX; \ + USE(rX); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rX = static_cast(static_cast(pc[1]) | \ + (static_cast(pc[2]) << 8) | \ + (static_cast(pc[3]) << 16) | \ + (static_cast(pc[4]) << 24)); \ + pc += 5; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rX = static_cast(pc[1]); \ + pc += 2; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_T(Name) \ + const KBCInstr* rT; \ + USE(rT); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rT = pc + (static_cast((static_cast(pc[1]) << 8) | \ + (static_cast(pc[2]) << 16) | \ + (static_cast(pc[3]) << 24)) >> \ + 8); \ + pc += 4; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rT = pc + static_cast(pc[1]); \ + pc += 2; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_A_E(Name) \ + uint32_t rA, rE; \ + USE(rA); \ + USE(rE); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + rE = static_cast(pc[2]) | (static_cast(pc[3]) << 8) | \ + (static_cast(pc[4]) << 16) | \ + (static_cast(pc[5]) << 24); \ + pc += 6; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + rE = pc[2]; \ + pc += 3; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_A_Y(Name) \ + uint32_t rA; \ + int32_t rY; \ + USE(rA); \ + USE(rY); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + rY = static_cast(static_cast(pc[2]) | \ + (static_cast(pc[3]) << 8) | \ + (static_cast(pc[4]) << 16) | \ + (static_cast(pc[5]) << 24)); \ + pc += 6; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + rY = static_cast(pc[2]); \ + pc += 3; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_D_F(Name) \ + uint32_t rD, rF; \ + USE(rD); \ + USE(rF); \ + BYTECODE_WIDE_ENTRY_LABEL(Name) \ + rD = static_cast(pc[1]) | (static_cast(pc[2]) << 8) | \ + (static_cast(pc[3]) << 16) | \ + (static_cast(pc[4]) << 24); \ + rF = pc[5]; \ + pc += 6; \ + GOTO_BYTECODE_IMPL(Name); \ + BYTECODE_ENTRY_LABEL(Name) \ + rD = pc[1]; \ + rF = pc[2]; \ + pc += 3; \ + BYTECODE_IMPL_LABEL(Name) + +#define BYTECODE_HEADER_A_B_C(Name) \ + uint32_t rA, rB, rC; \ + USE(rA); \ + USE(rB); \ + USE(rC); \ + BYTECODE_ENTRY_LABEL(Name) \ + rA = pc[1]; \ + rB = pc[2]; \ + rC = pc[3]; \ + pc += 4; + +#define HANDLE_EXCEPTION \ + do { \ + goto HandleException; \ + } while (0) + +#define HANDLE_RETURN \ + do { \ + pp_ = InterpreterHelpers::FrameBytecode(FP)->untag()->object_pool(); \ + } while (0) + +// Runtime call helpers: handle invocation and potential exception after return. +#define INVOKE_RUNTIME(Func, Args) \ + if (!InvokeRuntime(thread, this, Func, Args)) { \ + HANDLE_EXCEPTION; \ + } else { \ + HANDLE_RETURN; \ + } + +#define LOAD_CONSTANT(index) (pp_->untag()->data()[(index)].raw_obj_) + +#define UNBOX_INT64(value, obj, selector) \ + int64_t value; \ + { \ + if (LIKELY(!obj.IsHeapObject())) { \ + value = Smi::Value(Smi::RawCast(obj)); \ + } else { \ + if (UNLIKELY(obj == null_value)) { \ + SP[0] = selector.ptr(); \ + goto ThrowNullError; \ + } \ + value = Integer::GetInt64Value(Integer::RawCast(obj)); \ + } \ + } + +#define BOX_INT64_RESULT(result) \ + if (LIKELY(Smi::IsValid(result))) { \ + SP[0] = Smi::New(static_cast(result)); \ + } else if (!AllocateMint(thread, result, pc, FP, SP)) { \ + HANDLE_EXCEPTION; \ + } \ + ASSERT(Integer::GetInt64Value(Integer::RawCast(SP[0])) == result); + +#define UNBOX_DOUBLE(value, obj, selector) \ + double value; \ + { \ + if (UNLIKELY(obj == null_value)) { \ + SP[0] = selector.ptr(); \ + goto ThrowNullError; \ + } \ + value = Double::RawCast(obj)->untag()->value_; \ + } + +#define BOX_DOUBLE_RESULT(result) \ + if (!AllocateDouble(thread, result, pc, FP, SP)) { \ + HANDLE_EXCEPTION; \ + } \ + ASSERT(Utils::DoublesBitEqual(Double::RawCast(SP[0])->untag()->value_, \ + result)); + +bool Interpreter::CopyParameters(Thread* thread, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP, + const intptr_t num_fixed_params, + const intptr_t num_opt_pos_params, + const intptr_t num_opt_named_params, + const intptr_t num_reserved_locals) { + const intptr_t min_num_pos_args = num_fixed_params; + const intptr_t max_num_pos_args = num_fixed_params + num_opt_pos_params; + + // Decode arguments descriptor. + const intptr_t arg_count = InterpreterHelpers::ArgDescArgCount(argdesc_); + const intptr_t pos_count = InterpreterHelpers::ArgDescPosCount(argdesc_); + const intptr_t named_count = (arg_count - pos_count); + + // Check that got the right number of positional parameters. + if ((min_num_pos_args > pos_count) || (pos_count > max_num_pos_args)) { + return false; + } + + // Copy all passed position arguments. + ObjectPtr* first_arg = FrameArguments(*FP, arg_count); + memmove(*SP + 1, first_arg, pos_count * kWordSize); + + if (num_opt_named_params != 0) { + // This is a function with named parameters. + // Walk the list of named parameters and their + // default values encoded as pairs of LoadConstant instructions that + // follows the entry point and find matching values via arguments + // descriptor. + + intptr_t i = 0; // argument position + intptr_t j = 0; // parameter position + while ((j < num_opt_named_params) && (i < named_count)) { + // Fetch formal parameter information: name, default value, target slot. + const KBCInstr* load_name = *pc; + const KBCInstr* load_value = KernelBytecode::Next(load_name); + *pc = KernelBytecode::Next(load_value); + ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name)); + ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value)); + const uint8_t reg = KernelBytecode::DecodeA(load_name); + ASSERT(reg == KernelBytecode::DecodeA(load_value)); + ASSERT(reg >= num_reserved_locals); + + StringPtr name = static_cast( + LOAD_CONSTANT(KernelBytecode::DecodeE(load_name))); + if (name == + argdesc_->untag()->element(ArgumentsDescriptor::name_index(i))) { + // Parameter was passed. Fetch passed value. + const intptr_t arg_index = + Smi::Value(static_cast(argdesc_->untag()->element( + ArgumentsDescriptor::position_index(i)))); + (*FP)[reg] = first_arg[arg_index]; + ++i; // Consume passed argument. + } else { + // Parameter was not passed. Fetch default value. + (*FP)[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value)); + } + ++j; // Next formal parameter. + } + + // If we have unprocessed formal parameters then initialize them all + // using default values. + while (j < num_opt_named_params) { + const KBCInstr* load_name = *pc; + const KBCInstr* load_value = KernelBytecode::Next(load_name); + *pc = KernelBytecode::Next(load_value); + ASSERT(KernelBytecode::IsLoadConstantOpcode(load_name)); + ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value)); + const uint8_t reg = KernelBytecode::DecodeA(load_name); + ASSERT(reg == KernelBytecode::DecodeA(load_value)); + ASSERT(reg >= num_reserved_locals); + + (*FP)[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value)); + ++j; + } + + // If we have unprocessed passed arguments that means we have mismatch + // between formal parameters and concrete arguments. This can only + // occur if the current function is a closure. + if (i < named_count) { + return false; + } + + // SP points past copied arguments. + *SP = *SP + num_fixed_params + num_opt_named_params; + } else { + if (named_count != 0) { + // Function can't have both named and optional positional parameters. + // This kind of mismatch can only occur if the current function + // is a closure. + return false; + } + + // Process the list of default values encoded as a sequence of + // LoadConstant instructions after EntryOpt bytecode. + // Execute only those that correspond to parameters that were not passed. + for (intptr_t i = num_fixed_params; i < pos_count; ++i) { + ASSERT(KernelBytecode::IsLoadConstantOpcode(*pc)); + *pc = KernelBytecode::Next(*pc); + } + for (intptr_t i = pos_count; i < max_num_pos_args; ++i) { + const KBCInstr* load_value = *pc; + *pc = KernelBytecode::Next(load_value); + ASSERT(KernelBytecode::IsLoadConstantOpcode(load_value)); + const uint8_t reg = KernelBytecode::DecodeA(load_value); + ASSERT(reg == num_reserved_locals + i); + (*FP)[reg] = LOAD_CONSTANT(KernelBytecode::DecodeE(load_value)); + } + + // SP points past the last copied parameter. + *SP = *SP + max_num_pos_args; + } + + return true; +} + +bool Interpreter::AssertAssignable(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* call_top, + ObjectPtr* args, + SubtypeTestCachePtr cache) { + ObjectPtr null_value = Object::null(); + if (cache != null_value) { + InstancePtr instance = Instance::RawCast(args[0]); + TypeArgumentsPtr instantiator_type_arguments = + static_cast(args[2]); + TypeArgumentsPtr function_type_arguments = + static_cast(args[3]); + + const intptr_t cid = InterpreterHelpers::GetClassId(instance); + + TypeArgumentsPtr instance_type_arguments = + static_cast(null_value); + ObjectPtr instance_cid_or_function; + + TypeArgumentsPtr parent_function_type_arguments; + TypeArgumentsPtr delayed_function_type_arguments; + if (cid == kClosureCid) { + ClosurePtr closure = static_cast(instance); + instance_type_arguments = closure->untag()->instantiator_type_arguments(); + parent_function_type_arguments = + closure->untag()->function_type_arguments(); + delayed_function_type_arguments = + closure->untag()->delayed_type_arguments(); + instance_cid_or_function = + closure->untag()->function()->untag()->signature(); + } else { + instance_cid_or_function = Smi::New(cid); + + ClassPtr instance_class = thread->isolate_group()->class_table()->At(cid); + if (instance_class->untag()->num_type_arguments_ < 0) { + goto AssertAssignableCallRuntime; + } else if (instance_class->untag()->num_type_arguments_ > 0) { + instance_type_arguments = + GET_FIELD_T(TypeArgumentsPtr, instance, + instance_class->untag() + ->host_type_arguments_field_offset_in_words_); + } + parent_function_type_arguments = + static_cast(null_value); + delayed_function_type_arguments = + static_cast(null_value); + } + + ArrayPtr entries = cache->untag()->cache(); + for (intptr_t i = 0; entries->untag()->element(i) != null_value; + i += SubtypeTestCache::kTestEntryLength) { + if ((entries->untag()->element( + i + SubtypeTestCache::kInstanceCidOrSignature) == + instance_cid_or_function) && + (entries->untag()->element( + i + SubtypeTestCache::kInstanceTypeArguments) == + instance_type_arguments) && + (entries->untag()->element( + i + SubtypeTestCache::kInstantiatorTypeArguments) == + instantiator_type_arguments) && + (entries->untag()->element( + i + SubtypeTestCache::kFunctionTypeArguments) == + function_type_arguments) && + (entries->untag()->element( + i + SubtypeTestCache::kInstanceParentFunctionTypeArguments) == + parent_function_type_arguments) && + (entries->untag()->element( + i + SubtypeTestCache::kInstanceDelayedFunctionTypeArguments) == + delayed_function_type_arguments)) { + if (Bool::True().ptr() == + entries->untag()->element(i + SubtypeTestCache::kTestResult)) { + return true; + } else { + break; + } + } + } + } + +AssertAssignableCallRuntime: + // args[0]: Instance. + // args[1]: Type. + // args[2]: Instantiator type args. + // args[3]: Function type args. + // args[4]: Name. + args[5] = cache; + args[6] = Smi::New(kTypeCheckFromInline); + args[7] = 0; // Unused result. + Exit(thread, FP, args + 8, pc); + NativeArguments native_args(thread, 7, args, args + 7); + return InvokeRuntime(thread, this, DRT_TypeCheck, native_args); +} + +template +bool Interpreter::AssertAssignableField(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP, + InstancePtr instance, + FieldPtr field, + InstancePtr value) { + // TODO(alexmarkov) + return true; +} + +ObjectPtr Interpreter::Call(const Function& function, + const Array& arguments_descriptor, + const Array& arguments, + Thread* thread) { + return Call(function.ptr(), arguments_descriptor.ptr(), arguments.Length(), + nullptr, arguments.ptr(), thread); +} + +// Allocate a _Mint for the given int64_t value and puts it into SP[0]. +// Returns false on exception. +DART_NOINLINE bool Interpreter::AllocateMint(Thread* thread, + int64_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + ASSERT(!Smi::IsValid(value)); + MintPtr result; + if (TryAllocate(thread, kMintCid, Mint::InstanceSize(), + reinterpret_cast(&result))) { + result->untag()->value_ = value; + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = + thread->isolate_group()->object_store()->mint_class(); // Class object. + SP[2] = Object::null(); // Type arguments. + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + if (!InvokeRuntime(thread, this, DRT_AllocateObject, args)) { + return false; + } + Mint::RawCast(SP[0])->untag()->value_ = value; + return true; + } +} + +// Allocate a _Double for the given double value and put it into SP[0]. +// Returns false on exception. +DART_NOINLINE bool Interpreter::AllocateDouble(Thread* thread, + double value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + DoublePtr result; + if (TryAllocate(thread, kDoubleCid, Double::InstanceSize(), + reinterpret_cast(&result))) { + result->untag()->value_ = value; + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = thread->isolate_group()->object_store()->double_class(); + SP[2] = Object::null(); // Type arguments. + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + if (!InvokeRuntime(thread, this, DRT_AllocateObject, args)) { + return false; + } + Double::RawCast(SP[0])->untag()->value_ = value; + return true; + } +} + +// Allocate a _Float32x4 for the given simd value and put it into SP[0]. +// Returns false on exception. +DART_NOINLINE bool Interpreter::AllocateFloat32x4(Thread* thread, + simd128_value_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + Float32x4Ptr result; + if (TryAllocate(thread, kFloat32x4Cid, Float32x4::InstanceSize(), + reinterpret_cast(&result))) { + value.writeTo(result->untag()->value_); + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = thread->isolate_group()->object_store()->float32x4_class(); + SP[2] = Object::null(); // Type arguments. + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + if (!InvokeRuntime(thread, this, DRT_AllocateObject, args)) { + return false; + } + value.writeTo(Float32x4::RawCast(SP[0])->untag()->value_); + return true; + } +} + +// Allocate _Float64x2 box for the given simd value and put it into SP[0]. +// Returns false on exception. +DART_NOINLINE bool Interpreter::AllocateFloat64x2(Thread* thread, + simd128_value_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + Float64x2Ptr result; + if (TryAllocate(thread, kFloat64x2Cid, Float64x2::InstanceSize(), + reinterpret_cast(&result))) { + value.writeTo(result->untag()->value_); + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = thread->isolate_group()->object_store()->float64x2_class(); + SP[2] = Object::null(); // Type arguments. + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + if (!InvokeRuntime(thread, this, DRT_AllocateObject, args)) { + return false; + } + value.writeTo(Float64x2::RawCast(SP[0])->untag()->value_); + return true; + } +} + +// Allocate a _List with the given type arguments and length and put it into +// SP[0]. Returns false on exception. +bool Interpreter::AllocateArray(Thread* thread, + TypeArgumentsPtr type_args, + ObjectPtr length_object, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + if (LIKELY(!length_object->IsHeapObject())) { + const intptr_t length = Smi::Value(Smi::RawCast(length_object)); + if (LIKELY(Array::IsValidLength(length))) { + ArrayPtr result; + if (TryAllocate(thread, kArrayCid, Array::InstanceSize(length), + reinterpret_cast(&result))) { + result->untag()->set_type_arguments(type_args); + result->untag()->set_length(Smi::New(length)); + for (intptr_t i = 0; i < length; i++) { + result->untag()->set_element(i, Object::null(), thread); + } + SP[0] = result; + return true; + } + } + } + + SP[0] = 0; // Space for the result; + SP[1] = length_object; + SP[2] = type_args; + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + return InvokeRuntime(thread, this, DRT_AllocateArray, args); +} + +// Allocate a _Context with the given length and put it into SP[0]. +// Returns false on exception. +bool Interpreter::AllocateContext(Thread* thread, + intptr_t num_context_variables, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + ContextPtr result; + if (TryAllocate(thread, kContextCid, + Context::InstanceSize(num_context_variables), + reinterpret_cast(&result))) { + result->untag()->num_variables_ = num_context_variables; + ObjectPtr null_value = Object::null(); + result->untag()->set_parent(static_cast(null_value)); + for (intptr_t i = 0; i < num_context_variables; i++) { + result->untag()->set_element(i, null_value, thread); + } + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = Smi::New(num_context_variables); + Exit(thread, FP, SP + 2, pc); + NativeArguments args(thread, 1, SP + 1, SP); + return InvokeRuntime(thread, this, DRT_AllocateContext, args); + } +} + +// Allocate a _Closure and put it into SP[0]. +// Returns false on exception. +bool Interpreter::AllocateClosure(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP) { + const intptr_t instance_size = Closure::InstanceSize(); + ClosurePtr result; + if (TryAllocate(thread, kClosureCid, instance_size, + reinterpret_cast(&result))) { + uword start = UntaggedObject::ToAddr(result); + ObjectPtr null_value = Object::null(); + for (intptr_t offset = sizeof(UntaggedInstance); offset < instance_size; + offset += kWordSize) { + *reinterpret_cast(start + offset) = null_value; + } + SP[0] = result; + return true; + } else { + SP[0] = 0; // Space for the result. + SP[1] = thread->isolate_group()->object_store()->closure_class(); + SP[2] = Object::null(); // Type arguments. + Exit(thread, FP, SP + 3, pc); + NativeArguments args(thread, 2, SP + 1, SP); + return InvokeRuntime(thread, this, DRT_AllocateObject, args); + } +} + +ObjectPtr Interpreter::Call(FunctionPtr function, + ArrayPtr argdesc, + intptr_t argc, + ObjectPtr const* argv, + ArrayPtr args_array, + Thread* thread) { + // Interpreter state (see constants_kbc.h for high-level overview). + const KBCInstr* pc; // Program Counter: points to the next op to execute. + ObjectPtr* FP; // Frame Pointer. + ObjectPtr* SP; // Stack Pointer. + + uint32_t op; // Currently executing op. + + bool reentering = fp_ != NULL; + if (!reentering) { + fp_ = reinterpret_cast(stack_base_); + } +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("%s interpreter 0x%" Px " at fp_ 0x%" Px " exit 0x%" Px " %s\n", + reentering ? "Re-entering" : "Entering", + reinterpret_cast(this), reinterpret_cast(fp_), + thread->top_exit_frame_info(), + Function::Handle(function).ToFullyQualifiedCString()); + } +#endif + + // Setup entry frame: + // + // ^ + // | previous Dart frames + // | + // | ........... | -+ + // fp_ > | exit fp_ | saved top_exit_frame_info + // | argdesc_ | saved argdesc_ (for reentering interpreter) + // | pp_ | saved pp_ (for reentering interpreter) + // | arg 0 | -+ + // | arg 1 | | + // ... | + // > incoming arguments + // | + // | arg argc-1 | -+ + // | function | -+ + // | code | | + // | caller PC | ---> special fake PC marking an entry frame + // SP > | fp_ | | + // FP > | ........... | > normal Dart frame (see stack_frame_kbc.h) + // | + // v + // + // A negative argc indicates reverse memory order of arguments. + const intptr_t arg_count = argc < 0 ? -argc : argc; + FP = fp_ + kKBCEntrySavedSlots + arg_count + kKBCDartFrameFixedSize; + SP = FP - 1; + + // Save outer top_exit_frame_info, current argdesc, and current pp. + fp_[kKBCExitLinkSlotFromEntryFp] = + static_cast(thread->top_exit_frame_info()); + thread->set_top_exit_frame_info(0); + fp_[kKBCSavedArgDescSlotFromEntryFp] = static_cast(argdesc_); + fp_[kKBCSavedPpSlotFromEntryFp] = static_cast(pp_); + + // Copy arguments and setup the Dart frame. + if (argv != nullptr) { + for (intptr_t i = 0; i < arg_count; ++i) { + fp_[kKBCEntrySavedSlots + i] = argv[argc < 0 ? -i : i]; + } + } else { + ASSERT(arg_count == Smi::Value(args_array->untag()->length())); + for (intptr_t i = 0; i < arg_count; ++i) { + fp_[kKBCEntrySavedSlots + i] = args_array->untag()->element(i); + } + } + + BytecodePtr bytecode = Function::GetBytecode(function); + FP[kKBCFunctionSlotFromFp] = function; + FP[kKBCPcMarkerSlotFromFp] = bytecode; + FP[kKBCSavedCallerPcSlotFromFp] = static_cast(kEntryFramePcMarker); + FP[kKBCSavedCallerFpSlotFromFp] = + static_cast(reinterpret_cast(fp_)); + + // Load argument descriptor. + argdesc_ = argdesc; + + // Ready to start executing bytecode. Load entry point and corresponding + // object pool. + pc = reinterpret_cast(bytecode->untag()->instructions_); + NOT_IN_PRODUCT(pc_ = pc); // For the profiler. + NOT_IN_PRODUCT(fp_ = FP); // For the profiler. + pp_ = bytecode->untag()->object_pool(); + + // Save current VM tag and mark thread as executing Dart code. For the + // profiler, do this *after* setting up the entry frame (compare the machine + // code entry stubs). + const uword vm_tag = thread->vm_tag(); + thread->set_vm_tag(VMTag::kDartInterpretedTagId); + + // Save current top stack resource and reset the list. + StackResource* top_resource = thread->top_resource(); + thread->set_top_resource(NULL); + + // Cache some frequently used values in the frame. + BoolPtr true_value = Bool::True().ptr(); + BoolPtr false_value = Bool::False().ptr(); + ObjectPtr null_value = Object::null(); + +#ifdef DART_HAS_COMPUTED_GOTO + static const void* dispatch[] = { +#define TARGET(name, fmt, kind, fmta, fmtb, fmtc) &&bc##name, + KERNEL_BYTECODES_LIST(TARGET) +#undef TARGET + }; + DISPATCH(); // Enter the dispatch loop. +#else + DISPATCH(); // Enter the dispatch loop. +SwitchDispatch: + switch (op & 0xFF) { +#define TARGET(name, fmt, kind, fmta, fmtb, fmtc) \ + case KernelBytecode::k##name: \ + goto bc##name; + KERNEL_BYTECODES_LIST(TARGET) +#undef TARGET + default: + FATAL1("Undefined opcode: %d\n", op); + } +#endif + + // KernelBytecode handlers (see constants_kbc.h for bytecode descriptions). + { + BYTECODE(Entry, D); + const intptr_t num_locals = rD; + + // Initialize locals with null & set SP. + for (intptr_t i = 0; i < num_locals; i++) { + FP[i] = null_value; + } + SP = FP + num_locals - 1; + + DISPATCH(); + } + + { + BYTECODE(EntryOptional, A_B_C); + SP = FP - 1; + if (CopyParameters(thread, &pc, &FP, &SP, rA, rB, rC, 0)) { + DISPATCH(); + } else { + SP[1] = FrameFunction(FP); + goto NoSuchMethodFromPrologue; + } + } + + { + BYTECODE(EntrySuspendable, A_B_C); + FP[kKBCSuspendStateSlotFromFp] = null_value; + SP = FP + kKBCSuspendStateSlotFromFp; + if (CopyParameters(thread, &pc, &FP, &SP, rA, rB, rC, 1)) { + DISPATCH(); + } else { + SP[1] = FrameFunction(FP); + goto NoSuchMethodFromPrologue; + } + } + + { + BYTECODE(Frame, D); + // Initialize locals with null and increment SP. + const intptr_t num_locals = rD; + for (intptr_t i = 1; i <= num_locals; i++) { + SP[i] = null_value; + } + SP += num_locals; + + DISPATCH(); + } + + { + BYTECODE(SetFrame, A); + SP = FP + rA - 1; + DISPATCH(); + } + + { + BYTECODE(CheckStack, A); + { + // Check the interpreter's own stack limit for actual interpreter's stack + // overflows, and also the thread's stack limit for scheduled interrupts. + if (reinterpret_cast(SP) >= overflow_stack_limit() || + thread->HasScheduledInterrupts()) { + Exit(thread, FP, SP + 1, pc); + INVOKE_RUNTIME(DRT_InterruptOrStackOverflow, + NativeArguments(thread, 0, nullptr, nullptr)); + } + } + DISPATCH(); + } + + { + BYTECODE(DebugCheck, 0); + + DISPATCH(); + } + + { + BYTECODE(CheckFunctionTypeArgs, A_E); + const intptr_t declared_type_args_len = rA; + const intptr_t first_stack_local_index = rE; + + // Decode arguments descriptor's type args len. + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + if ((type_args_len != declared_type_args_len) && (type_args_len != 0)) { + SP[1] = FrameFunction(FP); + goto NoSuchMethodFromPrologue; + } + if (type_args_len > 0) { + // Decode arguments descriptor's argument count (excluding type args). + const intptr_t arg_count = InterpreterHelpers::ArgDescArgCount(argdesc_); + // Copy passed-in type args to first local slot. + FP[first_stack_local_index] = *FrameArguments(FP, arg_count + 1); + } else if (declared_type_args_len > 0) { + FP[first_stack_local_index] = Object::null(); + } + DISPATCH(); + } + + { + BYTECODE(InstantiateType, D); + // Stack: instantiator type args, function type args + ObjectPtr type = LOAD_CONSTANT(rD); + SP[1] = type; + SP[2] = SP[-1]; + SP[3] = SP[0]; + Exit(thread, FP, SP + 4, pc); + { + INVOKE_RUNTIME(DRT_InstantiateType, + NativeArguments(thread, 3, SP + 1, SP - 1)); + } + SP -= 1; + DISPATCH(); + } + + { + BYTECODE(InstantiateTypeArgumentsTOS, A_E); + // Stack: instantiator type args, function type args + TypeArgumentsPtr type_arguments = + static_cast(LOAD_CONSTANT(rE)); + + ObjectPtr instantiator_type_args = SP[-1]; + ObjectPtr function_type_args = SP[0]; + // If both instantiators are null and if the type argument vector + // instantiated from null becomes a vector of dynamic, then use null as + // the type arguments. + if ((rA == 0) || (null_value != instantiator_type_args) || + (null_value != function_type_args)) { + SP[1] = type_arguments; + SP[2] = instantiator_type_args; + SP[3] = function_type_args; + + Exit(thread, FP, SP + 4, pc); + INVOKE_RUNTIME(DRT_InstantiateTypeArguments, + NativeArguments(thread, 3, SP + 1, SP - 1)); + } + + SP -= 1; + DISPATCH(); + } + + { + BYTECODE(Throw, A); + { + if (rA == 0) { // Throw + SP[1] = 0; // Space for result. + Exit(thread, FP, SP + 2, pc); + INVOKE_RUNTIME(DRT_Throw, NativeArguments(thread, 1, SP, SP + 1)); + } else { // ReThrow + SP[1] = 0; // Do not bypass debugger. + SP[2] = 0; // Space for result. + Exit(thread, FP, SP + 3, pc); + INVOKE_RUNTIME(DRT_ReThrow, NativeArguments(thread, 3, SP - 1, SP + 2)); + } + } + DISPATCH(); + } + + { + BYTECODE(Drop1, 0); + SP--; + DISPATCH(); + } + + { + BYTECODE(LoadConstant, A_E); + FP[rA] = LOAD_CONSTANT(rE); + DISPATCH(); + } + + { + BYTECODE(PushConstant, D); + *++SP = LOAD_CONSTANT(rD); + DISPATCH(); + } + + { + BYTECODE(PushNull, 0); + *++SP = null_value; + DISPATCH(); + } + + { + BYTECODE(PushTrue, 0); + *++SP = true_value; + DISPATCH(); + } + + { + BYTECODE(PushFalse, 0); + *++SP = false_value; + DISPATCH(); + } + + { + BYTECODE(PushInt, X); + *++SP = Smi::New(rX); + DISPATCH(); + } + + { + BYTECODE(Push, X); + *++SP = FP[rX]; + DISPATCH(); + } + + { + BYTECODE(StoreLocal, X); + FP[rX] = *SP; + DISPATCH(); + } + + { + BYTECODE(PopLocal, X); + FP[rX] = *SP--; + DISPATCH(); + } + + { + BYTECODE(MoveSpecial, A_Y); + ASSERT(rA < KernelBytecode::kSpecialIndexCount); + FP[rY] = special_[rA]; + DISPATCH(); + } + + { + BYTECODE(BooleanNegateTOS, 0); + SP[0] = (SP[0] == true_value) ? false_value : true_value; + DISPATCH(); + } + + { + BYTECODE(DirectCall, D_F); + + // Invoke target function. + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + *++SP = LOAD_CONSTANT(kidx); + ObjectPtr* call_base = SP - argc; + ObjectPtr* call_top = SP; + argdesc_ = static_cast(LOAD_CONSTANT(kidx + 1)); + if (!Invoke(thread, call_base, call_top, &pc, &FP, &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(UncheckedDirectCall, D_F); + + // Invoke target function. + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + *++SP = LOAD_CONSTANT(kidx); + ObjectPtr* call_base = SP - argc; + ObjectPtr* call_top = SP; + argdesc_ = static_cast(LOAD_CONSTANT(kidx + 1)); + if (!Invoke(thread, call_base, call_top, &pc, &FP, &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(InterfaceCall, D_F); + + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + StringPtr target_name = + static_cast(LOAD_CONSTANT(kidx))->untag()->name(); + argdesc_ = static_cast(LOAD_CONSTANT(kidx + 1)); + if (!InstanceCall(thread, target_name, call_base, call_top, &pc, &FP, + &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + { + BYTECODE(InstantiatedInterfaceCall, D_F); + + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + StringPtr target_name = + static_cast(LOAD_CONSTANT(kidx))->untag()->name(); + argdesc_ = static_cast(LOAD_CONSTANT(kidx + 1)); + if (!InstanceCall(thread, target_name, call_base, call_top, &pc, &FP, + &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(UncheckedClosureCall, D_F); + + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + ClosurePtr receiver = Closure::RawCast(*SP--); + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + if (UNLIKELY(receiver == null_value)) { + SP[0] = Symbols::call().ptr(); + goto ThrowNullError; + } + argdesc_ = static_cast(LOAD_CONSTANT(kidx)); + call_top[0] = receiver->untag()->function(); + + if (!Invoke(thread, call_base, call_top, &pc, &FP, &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(UncheckedInterfaceCall, D_F); + + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + StringPtr target_name = + static_cast(LOAD_CONSTANT(kidx))->untag()->name(); + argdesc_ = static_cast(LOAD_CONSTANT(kidx + 1)); + if (!InstanceCall(thread, target_name, call_base, call_top, &pc, &FP, + &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(DynamicCall, D_F); + + { + const uint32_t argc = rF; + const uint32_t kidx = rD; + + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + + InterpreterHelpers::IncrementUsageCounter(FrameFunction(FP)); + StringPtr target_name = String::RawCast(LOAD_CONSTANT(kidx)); + argdesc_ = Array::RawCast(LOAD_CONSTANT(kidx + 1)); + if (!InstanceCall(thread, target_name, call_base, call_top, &pc, &FP, + &SP)) { + HANDLE_EXCEPTION; + } + } + + DISPATCH(); + } + + { + BYTECODE(ReturnTOS, 0); + + ReturnTOS: + ObjectPtr result; // result to return to the caller. + result = *SP; + // Restore caller PC. + pc = SavedCallerPC(FP); + + // Check if it is a fake PC marking the entry frame. + if (IsEntryFrameMarker(pc)) { + // Pop entry frame. + ObjectPtr* entry_fp = SavedCallerFP(FP); + // Restore exit frame info saved in entry frame. + pp_ = static_cast(entry_fp[kKBCSavedPpSlotFromEntryFp]); + argdesc_ = + static_cast(entry_fp[kKBCSavedArgDescSlotFromEntryFp]); + uword exit_fp = static_cast(entry_fp[kKBCExitLinkSlotFromEntryFp]); + thread->set_top_exit_frame_info(exit_fp); + thread->set_top_resource(top_resource); + thread->set_vm_tag(vm_tag); + fp_ = entry_fp; + NOT_IN_PRODUCT(pc_ = pc); // For the profiler. +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("Returning from interpreter 0x%" Px " at fp_ 0x%" Px + " exit 0x%" Px "\n", + reinterpret_cast(this), reinterpret_cast(fp_), + exit_fp); + } + ASSERT(HasFrame(reinterpret_cast(fp_))); + // Exception propagation should have been done. + ASSERT(!result->IsHeapObject() || + result->GetClassId() != kUnhandledExceptionCid); +#endif + return result; + } + + // Look at the caller to determine how many arguments to pop. + const uint8_t argc = KernelBytecode::DecodeArgc(pc); + + // Restore SP, FP and PP. Push result and dispatch. + SP = FrameArguments(FP, argc); + FP = SavedCallerFP(FP); + NOT_IN_PRODUCT(fp_ = FP); // For the profiler. + NOT_IN_PRODUCT(pc_ = pc); // For the profiler. + pp_ = InterpreterHelpers::FrameBytecode(FP)->untag()->object_pool(); + *SP = result; +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("Returning to %s (argc %d)\n", + Function::Handle(FrameFunction(FP)).ToFullyQualifiedCString(), + static_cast(argc)); + } +#endif + DISPATCH(); + } + + { + BYTECODE(ReturnAsync, 0); + + argdesc_ = ArgumentsDescriptor::NewBoxed(0, 2); + ObjectPtr return_value = *SP; + ObjectPtr suspend_state = FP[kKBCSuspendStateSlotFromFp]; + FP[kKBCSuspendStateSlotFromFp] = null_value; + + FunctionPtr function = + thread->isolate_group()->object_store()->suspend_state_return_async(); + ASSERT(Function::HasCode(function)); + + SP[0] = suspend_state; + SP[1] = return_value; + ObjectPtr* call_base = SP; + ObjectPtr* call_top = SP + 2; + call_top[0] = function; + if (!InvokeCompiled(thread, function, call_base, call_top, &pc, &FP, &SP)) { + HANDLE_EXCEPTION; + } else { + HANDLE_RETURN; + } + goto ReturnTOS; + } + + { + BYTECODE(ReturnAsyncStar, 0); + + argdesc_ = ArgumentsDescriptor::NewBoxed(0, 2); + ObjectPtr return_value = *SP; + ObjectPtr suspend_state = FP[kKBCSuspendStateSlotFromFp]; + FP[kKBCSuspendStateSlotFromFp] = null_value; + + FunctionPtr function = thread->isolate_group() + ->object_store() + ->suspend_state_return_async_star(); + ASSERT(Function::HasCode(function)); + + SP[0] = suspend_state; + SP[1] = return_value; + ObjectPtr* call_base = SP; + ObjectPtr* call_top = SP + 2; + call_top[0] = function; + if (!InvokeCompiled(thread, function, call_base, call_top, &pc, &FP, &SP)) { + HANDLE_EXCEPTION; + } else { + HANDLE_RETURN; + } + goto ReturnTOS; + } + + { + BYTECODE(ReturnSyncStar, 0); + // Return false from sync* function to indicate the end of iteration. + *SP = false_value; + goto ReturnTOS; + } + + { + BYTECODE(InitLateField, D); + FieldPtr field = RAW_CAST(Field, LOAD_CONSTANT(rD + 1)); + InstancePtr instance = Instance::RawCast(SP[0]); + intptr_t offset_in_words = + Smi::Value(field->untag()->host_offset_or_field_id()); + + InterpreterHelpers::SetField(instance, offset_in_words, + Object::sentinel().ptr(), thread); + + SP -= 1; // Drop instance. + DISPATCH(); + } + + { + BYTECODE(PushUninitializedSentinel, 0); + *++SP = Object::sentinel().ptr(); + DISPATCH(); + } + + { + BYTECODE(JumpIfInitialized, T); + SP -= 1; + if (SP[1] != Object::sentinel().ptr()) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(StoreStaticTOS, D); + FieldPtr field = Field::RawCast(LOAD_CONSTANT(rD)); + InstancePtr value = Instance::RawCast(*SP--); + intptr_t field_id = Smi::Value(field->untag()->host_offset_or_field_id()); + thread->field_table_values()[field_id] = value; + DISPATCH(); + } + + { + BYTECODE(LoadStatic, D); + FieldPtr field = Field::RawCast(LOAD_CONSTANT(rD)); + intptr_t field_id = Smi::Value(field->untag()->host_offset_or_field_id()); + ObjectPtr value = thread->field_table_values()[field_id]; + ASSERT(value != Object::sentinel().ptr()); + *++SP = value; + DISPATCH(); + } + + { + BYTECODE(StoreFieldTOS, D); + FieldPtr field = RAW_CAST(Field, LOAD_CONSTANT(rD + 1)); + InstancePtr instance = Instance::RawCast(SP[-1]); + ObjectPtr value = static_cast(SP[0]); + intptr_t offset_in_words = + Smi::Value(field->untag()->host_offset_or_field_id()); + + if (InterpreterHelpers::FieldNeedsGuardUpdate(thread, field, value)) { + SP[1] = 0; // Unused result of runtime call. + SP[2] = field; + SP[3] = value; + Exit(thread, FP, SP + 4, pc); + if (!InvokeRuntime(thread, this, DRT_UpdateFieldCid, + NativeArguments(thread, 2, /* argv */ SP + 2, + /* retval */ SP + 1))) { + HANDLE_EXCEPTION; + } + + // Reload objects after the call which may trigger GC. + field = RAW_CAST(Field, LOAD_CONSTANT(rD + 1)); + instance = Instance::RawCast(SP[-1]); + value = SP[0]; + } + + const bool is_unboxed = + Field::UnboxedBit::decode(field->untag()->kind_bits_); + if (is_unboxed) { + const classid_t guarded_cid = field->untag()->guarded_cid_; + switch (guarded_cid) { + case kDoubleCid: { + double raw_value = Double::RawCast(value)->untag()->value_; + *reinterpret_cast( + reinterpret_cast(instance->untag()) + + offset_in_words) = raw_value; + break; + } + case kFloat32x4Cid: { + simd128_value_t raw_value; + raw_value.readFrom(Float32x4::RawCast(value)->untag()->value_); + *reinterpret_cast( + reinterpret_cast(instance->untag()) + + offset_in_words) = raw_value; + break; + } + case kFloat64x2Cid: { + simd128_value_t raw_value; + raw_value.readFrom(Float64x2::RawCast(value)->untag()->value_); + *reinterpret_cast( + reinterpret_cast(instance->untag()) + + offset_in_words) = raw_value; + break; + } + default: { + int64_t raw_value = Integer::GetInt64Value(Integer::RawCast(value)); + *reinterpret_cast( + reinterpret_cast(instance->untag()) + + offset_in_words) = raw_value; + break; + } + } + } else { + InterpreterHelpers::SetField(instance, offset_in_words, value, thread); + } + + SP -= 2; // Drop instance and value. + DISPATCH(); + } + + { + BYTECODE(StoreContextParent, 0); + ContextPtr instance = static_cast(SP[-1]); + ContextPtr value = static_cast(SP[0]); + SP -= 2; // Drop instance and value. + instance->untag()->set_parent(value); + DISPATCH(); + } + + { + BYTECODE(StoreContextVar, A_E); + const intptr_t index = rE; + ContextPtr instance = static_cast(SP[-1]); + ObjectPtr value = static_cast(SP[0]); + SP -= 2; // Drop instance and value. + ASSERT(index < instance->untag()->num_variables_); + instance->untag()->set_element(index, value, thread); + DISPATCH(); + } + + { + BYTECODE(LoadFieldTOS, D); +#if defined(DEBUG) + // Currently only used to load closure fields, which are not unboxed. + // If used for general field, boxing of the unboxed fields must be added. + FieldPtr field = RAW_CAST(Field, LOAD_CONSTANT(rD + 1)); + ASSERT(!Field::UnboxedBit::decode(field->untag()->kind_bits_)); +#endif + const uword offset_in_words = + static_cast(Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD)))); + InstancePtr instance = Instance::RawCast(SP[0]); + SP[0] = GET_FIELD(instance, offset_in_words); + DISPATCH(); + } + + { + BYTECODE(LoadTypeArgumentsField, D); + const uword offset_in_words = + static_cast(Smi::Value(RAW_CAST(Smi, LOAD_CONSTANT(rD)))); + InstancePtr instance = Instance::RawCast(SP[0]); + SP[0] = GET_FIELD(instance, offset_in_words); + DISPATCH(); + } + + { + BYTECODE(LoadContextParent, 0); + ContextPtr instance = static_cast(SP[0]); + SP[0] = instance->untag()->parent(); + DISPATCH(); + } + + { + BYTECODE(LoadContextVar, A_E); + const intptr_t index = rE; + ContextPtr instance = Context::RawCast(SP[0]); + ASSERT(index < instance->untag()->num_variables_); + SP[0] = instance->untag()->element(index); + DISPATCH(); + } + + { + BYTECODE(AllocateContext, A_E); + ++SP; + const uint32_t num_context_variables = rE; + if (!AllocateContext(thread, num_context_variables, pc, FP, SP)) { + HANDLE_EXCEPTION; + } + DISPATCH(); + } + + { + BYTECODE(CloneContext, A_E); + { + SP[1] = SP[0]; // Context to clone. + Exit(thread, FP, SP + 2, pc); + INVOKE_RUNTIME(DRT_CloneContext, NativeArguments(thread, 1, SP + 1, SP)); + } + DISPATCH(); + } + + { + BYTECODE(Allocate, D); + ClassPtr cls = Class::RawCast(LOAD_CONSTANT(rD)); + if (LIKELY(InterpreterHelpers::IsAllocateFinalized(cls))) { + const intptr_t class_id = cls->untag()->id_; + ASSERT(Class::is_valid_id(class_id)); + const intptr_t instance_size = + cls->untag()->host_instance_size_in_words_ * kCompressedWordSize; + ObjectPtr result; + if (TryAllocate(thread, class_id, instance_size, &result)) { + uword start = UntaggedObject::ToAddr(result); + const uword ptr_field_end_offset = + instance_size - (Instance::ContainsCompressedPointers() + ? kCompressedWordSize + : kWordSize); + Object::InitializeObject(start, class_id, instance_size, + Instance::ContainsCompressedPointers(), + Object::from_offset(), + ptr_field_end_offset); + /* + for (intptr_t offset = sizeof(UntaggedInstance); offset < instance_size; + offset += kCompressedWordSize) { + *reinterpret_cast(start + offset) = null_value; + } +*/ + ASSERT(class_id == + UntaggedObject::ClassIdTag::decode(result->untag()->tags_)); + ASSERT(IsolateGroup::Current()->class_table()->At( + result->GetClassId()) == cls); + *++SP = result; + DISPATCH(); + } + } + + SP[1] = 0; // Space for the result. + SP[2] = cls; // Class object. + SP[3] = null_value; // Type arguments. + Exit(thread, FP, SP + 4, pc); + INVOKE_RUNTIME(DRT_AllocateObject, + NativeArguments(thread, 2, SP + 2, SP + 1)); + SP++; // Result is in SP[1]. + DISPATCH(); + } + + { + BYTECODE(AllocateT, 0); + ClassPtr cls = Class::RawCast(SP[0]); + TypeArgumentsPtr type_args = TypeArguments::RawCast(SP[-1]); + if (LIKELY(InterpreterHelpers::IsAllocateFinalized(cls))) { + const intptr_t class_id = cls->untag()->id_; + const intptr_t instance_size = cls->untag()->host_instance_size_in_words_ + << kWordSizeLog2; + ObjectPtr result; + if (TryAllocate(thread, class_id, instance_size, &result)) { + uword start = UntaggedObject::ToAddr(result); + const uword ptr_field_end_offset = + instance_size - (Instance::ContainsCompressedPointers() + ? kCompressedWordSize + : kWordSize); + Object::InitializeObject(start, class_id, instance_size, + Instance::ContainsCompressedPointers(), + Object::from_offset(), + ptr_field_end_offset); + /* + for (intptr_t offset = sizeof(UntaggedInstance); offset < instance_size; + offset += kWordSize) { + *reinterpret_cast(start + offset) = null_value; + } +*/ + const intptr_t type_args_offset = + cls->untag()->host_type_arguments_field_offset_in_words_; + InterpreterHelpers::SetField(result, type_args_offset, type_args, + thread); + *--SP = result; + DISPATCH(); + } + } + + SP[1] = cls; + SP[2] = type_args; + Exit(thread, FP, SP + 3, pc); + INVOKE_RUNTIME(DRT_AllocateObject, + NativeArguments(thread, 2, SP + 1, SP - 1)); + SP -= 1; // Result is in SP - 1. + DISPATCH(); + } + + { + BYTECODE(CreateArrayTOS, 0); + TypeArgumentsPtr type_args = TypeArguments::RawCast(SP[-1]); + ObjectPtr length = SP[0]; + SP--; + if (!AllocateArray(thread, type_args, length, pc, FP, SP)) { + HANDLE_EXCEPTION; + } + DISPATCH(); + } + + { + BYTECODE(AssertAssignable, A_E); + // Stack: instance, type, instantiator type args, function type args, name + ObjectPtr* args = SP - 4; + const bool may_be_smi = (rA == 1); + const bool is_smi = + ((static_cast(args[0]) & kSmiTagMask) == kSmiTag); + const bool smi_ok = is_smi && may_be_smi; + if (!smi_ok && (args[0] != null_value)) { + SubtypeTestCachePtr cache = + static_cast(LOAD_CONSTANT(rE)); + + if (!AssertAssignable(thread, pc, FP, SP, args, cache)) { + HANDLE_EXCEPTION; + } + } + + SP -= 4; // Instance remains on stack. + DISPATCH(); + } + + { + BYTECODE(AssertSubtype, 0); + ObjectPtr* args = SP - 4; + + // TODO(kustermann): Implement fast case for common arguments. + + // The arguments on the stack look like: + // args[0] instantiator type args + // args[1] function type args + // args[2] sub_type + // args[3] super_type + // args[4] name + + // This is unused, since the negative case throws an exception. + SP++; + ObjectPtr* result_slot = SP; + + Exit(thread, FP, SP + 1, pc); + INVOKE_RUNTIME(DRT_SubtypeCheck, + NativeArguments(thread, 5, args, result_slot)); + + // Drop result slot and all arguments. + SP -= 6; + + DISPATCH(); + } + + { + BYTECODE(AssertBoolean, A); + ObjectPtr value = SP[0]; + if (rA != 0u) { // Should we perform type check? + if ((value == true_value) || (value == false_value)) { + goto AssertBooleanOk; + } + } else if (value != null_value) { + goto AssertBooleanOk; + } + + // Assertion failed. + { + SP[1] = SP[0]; // instance + Exit(thread, FP, SP + 2, pc); + INVOKE_RUNTIME(DRT_NonBoolTypeError, + NativeArguments(thread, 1, SP + 1, SP)); + } + + AssertBooleanOk: + DISPATCH(); + } + + { + BYTECODE(Jump, T); + LOAD_JUMP_TARGET(); + DISPATCH(); + } + + { + BYTECODE(JumpIfNoAsserts, T); + if (!thread->isolate_group()->asserts()) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfNotZeroTypeArgs, T); + if (InterpreterHelpers::ArgDescTypeArgsLen(argdesc_) != 0) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfEqStrict, T); + SP -= 2; + if (SP[1] == SP[2]) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfNeStrict, T); + SP -= 2; + if (SP[1] != SP[2]) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfTrue, T); + SP -= 1; + if (SP[1] == true_value) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfFalse, T); + SP -= 1; + if (SP[1] == false_value) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfNull, T); + SP -= 1; + if (SP[1] == null_value) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfNotNull, T); + SP -= 1; + if (SP[1] != null_value) { + LOAD_JUMP_TARGET(); + } + DISPATCH(); + } + + { + BYTECODE(JumpIfUnchecked, T); + // Interpreter is not tracking unchecked calls, so fall through to + // parameter type checks. + DISPATCH(); + } + + { + BYTECODE(StoreIndexedTOS, 0); + SP -= 3; + ArrayPtr array = RAW_CAST(Array, SP[1]); + SmiPtr index = RAW_CAST(Smi, SP[2]); + ObjectPtr value = SP[3]; + ASSERT(InterpreterHelpers::CheckIndex(index, array->untag()->length())); + array->untag()->set_element(Smi::Value(index), value, thread); + DISPATCH(); + } + + { + BYTECODE(EqualsNull, 0); + + SP[0] = (SP[0] == null_value) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(NullCheck, D); + + if (UNLIKELY(SP[0] == null_value)) { + // Load selector. + SP[0] = LOAD_CONSTANT(rD); + goto ThrowNullError; + } + SP -= 1; + + DISPATCH(); + } + + { + BYTECODE(NegateInt, 0); + + UNBOX_INT64(value, SP[0], Symbols::UnaryMinus()); + int64_t result = Utils::SubWithWrapAround(0, value); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(AddInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Plus()); + UNBOX_INT64(b, SP[1], Symbols::Plus()); + int64_t result = Utils::AddWithWrapAround(a, b); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(SubInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Minus()); + UNBOX_INT64(b, SP[1], Symbols::Minus()); + int64_t result = Utils::SubWithWrapAround(a, b); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(MulInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Star()); + UNBOX_INT64(b, SP[1], Symbols::Star()); + int64_t result = Utils::MulWithWrapAround(a, b); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(TruncDivInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::TruncDivOperator()); + UNBOX_INT64(b, SP[1], Symbols::TruncDivOperator()); + if (UNLIKELY(b == 0)) { + goto ThrowIntegerDivisionByZeroException; + } + int64_t result; + if (UNLIKELY((a == Mint::kMinValue) && (b == -1))) { + result = Mint::kMinValue; + } else { + result = a / b; + } + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(ModInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Percent()); + UNBOX_INT64(b, SP[1], Symbols::Percent()); + if (UNLIKELY(b == 0)) { + goto ThrowIntegerDivisionByZeroException; + } + int64_t result; + if (UNLIKELY((a == Mint::kMinValue) && (b == -1))) { + result = 0; + } else { + result = a % b; + if (result < 0) { + if (b < 0) { + result -= b; + } else { + result += b; + } + } + } + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(BitAndInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Ampersand()); + UNBOX_INT64(b, SP[1], Symbols::Ampersand()); + int64_t result = a & b; + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(BitOrInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::BitOr()); + UNBOX_INT64(b, SP[1], Symbols::BitOr()); + int64_t result = a | b; + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(BitXorInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::Caret()); + UNBOX_INT64(b, SP[1], Symbols::Caret()); + int64_t result = a ^ b; + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(ShlInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::LeftShiftOperator()); + UNBOX_INT64(b, SP[1], Symbols::LeftShiftOperator()); + if (b < 0) { + SP[0] = SP[1]; + goto ThrowArgumentError; + } + int64_t result = Utils::ShiftLeftWithTruncation(a, b); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(ShrInt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::RightShiftOperator()); + UNBOX_INT64(b, SP[1], Symbols::RightShiftOperator()); + if (b < 0) { + SP[0] = SP[1]; + goto ThrowArgumentError; + } + int64_t result = a >> Utils::Minimum(b, Mint::kBits); + BOX_INT64_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(CompareIntEq, 0); + + SP -= 1; + if (SP[0] == SP[1]) { + SP[0] = true_value; + } else if (!SP[0]->IsHeapObject() || !SP[1]->IsHeapObject() || + (SP[0] == null_value) || (SP[1] == null_value)) { + SP[0] = false_value; + } else { + int64_t a = Integer::GetInt64Value(RAW_CAST(Integer, SP[0])); + int64_t b = Integer::GetInt64Value(RAW_CAST(Integer, SP[1])); + SP[0] = (a == b) ? true_value : false_value; + } + DISPATCH(); + } + + { + BYTECODE(CompareIntGt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::RAngleBracket()); + UNBOX_INT64(b, SP[1], Symbols::RAngleBracket()); + SP[0] = (a > b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareIntLt, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::LAngleBracket()); + UNBOX_INT64(b, SP[1], Symbols::LAngleBracket()); + SP[0] = (a < b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareIntGe, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::GreaterEqualOperator()); + UNBOX_INT64(b, SP[1], Symbols::GreaterEqualOperator()); + SP[0] = (a >= b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareIntLe, 0); + + SP -= 1; + UNBOX_INT64(a, SP[0], Symbols::LessEqualOperator()); + UNBOX_INT64(b, SP[1], Symbols::LessEqualOperator()); + SP[0] = (a <= b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(NegateDouble, 0); + + UNBOX_DOUBLE(value, SP[0], Symbols::UnaryMinus()); + double result = -value; + BOX_DOUBLE_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(AddDouble, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::Plus()); + UNBOX_DOUBLE(b, SP[1], Symbols::Plus()); + double result = a + b; + BOX_DOUBLE_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(SubDouble, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::Minus()); + UNBOX_DOUBLE(b, SP[1], Symbols::Minus()); + double result = a - b; + BOX_DOUBLE_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(MulDouble, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::Star()); + UNBOX_DOUBLE(b, SP[1], Symbols::Star()); + double result = a * b; + BOX_DOUBLE_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(DivDouble, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::Slash()); + UNBOX_DOUBLE(b, SP[1], Symbols::Slash()); + double result = a / b; + BOX_DOUBLE_RESULT(result); + DISPATCH(); + } + + { + BYTECODE(CompareDoubleEq, 0); + + SP -= 1; + if ((SP[0] == null_value) || (SP[1] == null_value)) { + SP[0] = (SP[0] == SP[1]) ? true_value : false_value; + } else { + double a = Double::RawCast(SP[0])->untag()->value_; + double b = Double::RawCast(SP[1])->untag()->value_; + SP[0] = (a == b) ? true_value : false_value; + } + DISPATCH(); + } + + { + BYTECODE(CompareDoubleGt, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::RAngleBracket()); + UNBOX_DOUBLE(b, SP[1], Symbols::RAngleBracket()); + SP[0] = (a > b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareDoubleLt, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::LAngleBracket()); + UNBOX_DOUBLE(b, SP[1], Symbols::LAngleBracket()); + SP[0] = (a < b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareDoubleGe, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::GreaterEqualOperator()); + UNBOX_DOUBLE(b, SP[1], Symbols::GreaterEqualOperator()); + SP[0] = (a >= b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(CompareDoubleLe, 0); + + SP -= 1; + UNBOX_DOUBLE(a, SP[0], Symbols::LessEqualOperator()); + UNBOX_DOUBLE(b, SP[1], Symbols::LessEqualOperator()); + SP[0] = (a <= b) ? true_value : false_value; + DISPATCH(); + } + + { + BYTECODE(AllocateClosure, D); + ++SP; + if (!AllocateClosure(thread, pc, FP, SP)) { + HANDLE_EXCEPTION; + } + FunctionPtr function = Function::RawCast(LOAD_CONSTANT(rD)); + ASSERT(Function::KindOf(function) == UntaggedFunction::kClosureFunction); + ClosurePtr closure = Closure::RawCast(SP[0]); + closure->untag()->set_function(function); + ONLY_IN_PRECOMPILED(closure->untag()->entry_point_ = + function->untag()->entry_point_); + DISPATCH(); + } + + { + BYTECODE_ENTRY_LABEL(Trap); + +#define UNIMPLEMENTED_LABEL_ORDN(Name) +#define UNIMPLEMENTED_LABEL_WIDE(Name) +#define UNIMPLEMENTED_LABEL_RESV(Name) BYTECODE_ENTRY_LABEL(Name) +#define UNIMPLEMENTED_LABEL(name, encoding, kind, op1, op2, op3) \ + UNIMPLEMENTED_LABEL_##kind(name) + + KERNEL_BYTECODES_LIST(UNIMPLEMENTED_LABEL) + +#undef UNIMPLEMENTED_LABEL_ORDN +#undef UNIMPLEMENTED_LABEL_WIDE +#undef UNIMPLEMENTED_LABEL_RESV +#undef UNIMPLEMENTED_LABEL + + UNIMPLEMENTED(); + DISPATCH(); + } + + { + BYTECODE(VMInternal_ImplicitGetter, 0); + + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == UntaggedFunction::kImplicitGetter); + + // Field object is cached in function's data_. + FieldPtr field = Field::RawCast(function->untag()->data()); + intptr_t offset_in_words = + Smi::Value(field->untag()->host_offset_or_field_id()); + + const intptr_t kArgc = 1; + InstancePtr instance = Instance::RawCast(FrameArguments(FP, kArgc)[0]); + + ASSERT(!Field::UnboxedBit::decode(field->untag()->kind_bits_)); + ObjectPtr value = GET_FIELD(instance, offset_in_words); + + if (UNLIKELY(value == Object::sentinel().ptr())) { + SP[1] = 0; // Result slot. + SP[2] = instance; + SP[3] = field; + Exit(thread, FP, SP + 4, pc); + INVOKE_RUNTIME( + DRT_InitInstanceField, + NativeArguments(thread, 2, /* argv */ SP + 2, /* ret val */ SP + 1)); + + function = FrameFunction(FP); + instance = Instance::RawCast(SP[2]); + field = Field::RawCast(SP[3]); + offset_in_words = Smi::Value(field->untag()->host_offset_or_field_id()); + value = GET_FIELD(instance, offset_in_words); + } + + *++SP = value; + +#if !defined(PRODUCT) + if (UNLIKELY( + Field::NeedsLoadGuardBit::decode(field->untag()->kind_bits_))) { + if (!AssertAssignableField(thread, pc, FP, SP, instance, field, + Instance::RawCast(value))) { + HANDLE_EXCEPTION; + } + } +#endif + + DISPATCH(); + } + + { + BYTECODE(VMInternal_ImplicitSetter, 0); + + FunctionPtr function = FrameFunction(FP); + if (Function::KindOf(function) == + UntaggedFunction::kDynamicInvocationForwarder) { + function = Function::RawCast(function->untag()->data()); + } + ASSERT(Function::KindOf(function) == UntaggedFunction::kImplicitSetter); + + // Field object is cached in function's data_. + FieldPtr field = Field::RawCast(function->untag()->data()); + *++SP = field; + intptr_t offset_in_words = + Smi::Value(field->untag()->host_offset_or_field_id()); + const intptr_t kArgc = 2; + InstancePtr instance = Instance::RawCast(FrameArguments(FP, kArgc)[0]); + InstancePtr value = Instance::RawCast(FrameArguments(FP, kArgc)[1]); + + if (!AssertAssignableField(thread, pc, FP, SP, instance, field, + value)) { + HANDLE_EXCEPTION; + } + // Reload objects after the call which may trigger GC. + field = Field::RawCast(SP[0]); + instance = Instance::RawCast(FrameArguments(FP, kArgc)[0]); + value = Instance::RawCast(FrameArguments(FP, kArgc)[1]); + + if (InterpreterHelpers::FieldNeedsGuardUpdate(thread, field, value)) { + SP[1] = 0; // Unused result of runtime call. + SP[2] = field; + SP[3] = value; + Exit(thread, FP, SP + 4, pc); + if (!InvokeRuntime(thread, this, DRT_UpdateFieldCid, + NativeArguments(thread, 2, /* argv */ SP + 2, + /* retval */ SP + 1))) { + HANDLE_EXCEPTION; + } + + // Reload objects after the call which may trigger GC. + field = Field::RawCast(SP[0]); + instance = Instance::RawCast(FrameArguments(FP, kArgc)[0]); + value = Instance::RawCast(FrameArguments(FP, kArgc)[1]); + } + + ASSERT(!Field::UnboxedBit::decode(field->untag()->kind_bits_)); + InterpreterHelpers::SetField(instance, offset_in_words, value, thread); + + *SP = null_value; + + DISPATCH(); + } + + { + BYTECODE(VMInternal_ImplicitStaticGetter, 0); + + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kImplicitStaticGetter); + + // Field object is cached in function's data_. + FieldPtr field = Field::RawCast(function->untag()->data()); + intptr_t field_id = Smi::Value(field->untag()->host_offset_or_field_id()); + ObjectPtr value = thread->field_table_values()[field_id]; + if (value == Object::sentinel().ptr()) { + SP[1] = 0; // Unused result of invoking the initializer. + SP[2] = field; + Exit(thread, FP, SP + 3, pc); + INVOKE_RUNTIME(DRT_InitStaticField, + NativeArguments(thread, 1, SP + 2, SP + 1)); + + // Reload objects after the call which may trigger GC. + function = FrameFunction(FP); + field = Field::RawCast(function->untag()->data()); + // The field is initialized by the runtime call, but not returned. + intptr_t field_id = Smi::Value(field->untag()->host_offset_or_field_id()); + value = thread->field_table_values()[field_id]; + } + + // Field was initialized. Return its value. + *++SP = value; + +#if !defined(PRODUCT) + if (UNLIKELY( + Field::NeedsLoadGuardBit::decode(field->untag()->kind_bits_))) { + if (!AssertAssignableField(thread, pc, FP, SP, + Instance::RawCast(null_value), field, + Instance::RawCast(value))) { + HANDLE_EXCEPTION; + } + } +#endif + + DISPATCH(); + } + + { + BYTECODE(VMInternal_MethodExtractor, 0); + + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == UntaggedFunction::kMethodExtractor); + function = Function::RawCast(function->untag()->data()); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kImplicitClosureFunction); + + ASSERT(InterpreterHelpers::ArgDescTypeArgsLen(argdesc_) == 0); + + ++SP; + if (!AllocateClosure(thread, pc, FP, SP)) { + HANDLE_EXCEPTION; + } + + InstancePtr instance = Instance::RawCast(FrameArguments(FP, 1)[0]); + + ClosurePtr closure = Closure::RawCast(*SP); + closure->untag()->set_instantiator_type_arguments( + InterpreterHelpers::GetTypeArguments(thread, instance)); + // function_type_arguments is already null + closure->untag()->set_delayed_type_arguments( + Object::empty_type_arguments().ptr()); + closure->untag()->set_function(function); + ONLY_IN_PRECOMPILED(closure->untag()->entry_point_ = + function->untag()->entry_point_); + closure->untag()->set_context(instance); + // hash is already null + + DISPATCH(); + } + + { + BYTECODE(VMInternal_InvokeClosure, 0); + + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kInvokeFieldDispatcher); + const bool is_dynamic_call = + Function::IsDynamicInvocationForwarderName(function->untag()->name()); + + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + + ClosurePtr receiver = + Closure::RawCast(FrameArguments(FP, argc)[receiver_idx]); + SP[1] = receiver->untag()->function(); + + if (is_dynamic_call) { + { + SP[2] = null_value; + SP[3] = receiver; + SP[4] = argdesc_; + Exit(thread, FP, SP + 5, pc); + if (!InvokeRuntime(thread, this, DRT_ClosureArgumentsValid, + NativeArguments(thread, 2, SP + 3, SP + 2))) { + HANDLE_EXCEPTION; + } + receiver = Closure::RawCast(SP[3]); + argdesc_ = Array::RawCast(SP[4]); + } + + if (SP[2] != Bool::True().ptr()) { + goto NoSuchMethodFromPrologue; + } + + // TODO(dartbug.com/40813): Move other checks that are currently + // compiled in the closure body to here as they are also moved to + // FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher. + } + + goto TailCallSP1; + } + + { + BYTECODE(VMInternal_InvokeField, 0); + + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kInvokeFieldDispatcher); + + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ObjectPtr receiver = FrameArguments(FP, argc)[receiver_idx]; + + // Possibly demangle field name and invoke field getter on receiver. + { + SP[1] = argdesc_; // Save argdesc_. + SP[2] = 0; // Result of runtime call. + SP[3] = receiver; // Receiver. + SP[4] = + function->untag()->name(); // Field name (may change during call). + Exit(thread, FP, SP + 5, pc); + if (!InvokeRuntime(thread, this, DRT_GetFieldForDispatch, + NativeArguments(thread, 2, SP + 3, SP + 2))) { + HANDLE_EXCEPTION; + } + function = FrameFunction(FP); + argdesc_ = Array::RawCast(SP[1]); + } + + // If the field name in the arguments is different after the call, then + // this was a dynamic call. + StringPtr field_name = String::RawCast(SP[4]); + const bool is_dynamic_call = function->untag()->name() != field_name; + + // Replace receiver with field value, keep all other arguments, and + // invoke 'call' function, or if not found, invoke noSuchMethod. + FrameArguments(FP, argc)[receiver_idx] = receiver = SP[2]; + + // If the field value is a closure, no need to resolve 'call' function. + if (InterpreterHelpers::GetClassId(receiver) == kClosureCid) { + SP[1] = Closure::RawCast(receiver)->untag()->function(); + + if (is_dynamic_call) { + { + SP[2] = null_value; + SP[3] = receiver; + SP[4] = argdesc_; + Exit(thread, FP, SP + 5, pc); + if (!InvokeRuntime(thread, this, DRT_ClosureArgumentsValid, + NativeArguments(thread, 2, SP + 3, SP + 2))) { + HANDLE_EXCEPTION; + } + receiver = SP[3]; + argdesc_ = Array::RawCast(SP[4]); + } + + if (SP[2] != Bool::True().ptr()) { + goto NoSuchMethodFromPrologue; + } + + // TODO(dartbug.com/40813): Move other checks that are currently + // compiled in the closure body to here as they are also moved to + // FlowGraphBuilder::BuildGraphOfInvokeFieldDispatcher. + } + + goto TailCallSP1; + } + + // Otherwise, call runtime to resolve 'call' function. + { + SP[1] = 0; // Result slot. + SP[2] = receiver; + SP[3] = argdesc_; + Exit(thread, FP, SP + 4, pc); + if (!InvokeRuntime(thread, this, DRT_ResolveCallFunction, + NativeArguments(thread, 2, SP + 2, SP + 1))) { + HANDLE_EXCEPTION; + } + argdesc_ = Array::RawCast(SP[3]); + function = Function::RawCast(SP[1]); + receiver = SP[2]; + } + + if (function != Function::null()) { + SP[1] = function; + goto TailCallSP1; + } + + // Function 'call' could not be resolved for argdesc_. + // Invoke noSuchMethod. + SP[1] = null_value; + SP[2] = receiver; + SP[3] = Symbols::call().ptr(); // We failed to resolve the 'call' function. + SP[4] = argdesc_; + SP[5] = null_value; // Array of arguments (will be filled). + + // Allocate array of arguments. + { + SP[6] = Smi::New(argc); // length + SP[7] = null_value; // type + Exit(thread, FP, SP + 8, pc); + if (!InvokeRuntime(thread, this, DRT_AllocateArray, + NativeArguments(thread, 2, SP + 6, SP + 5))) { + HANDLE_EXCEPTION; + } + } + + // Copy arguments into the newly allocated array. + ObjectPtr* argv = FrameArguments(FP, argc); + ArrayPtr array = static_cast(SP[5]); + ASSERT(array->GetClassId() == kArrayCid); + for (intptr_t i = 0; i < argc; i++) { + array->untag()->set_element(i, argv[i], thread); + } + + // Invoke noSuchMethod passing down receiver, target name, argument + // descriptor, and array of arguments. + { + Exit(thread, FP, SP + 6, pc); + if (!InvokeRuntime(thread, this, DRT_InvokeNoSuchMethod, + NativeArguments(thread, 4, SP + 2, SP + 1))) { + HANDLE_EXCEPTION; + } + + ++SP; // Result at SP[0] + } + DISPATCH(); + } + + { + BYTECODE(VMInternal_ForwardDynamicInvocation, 0); + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kDynamicInvocationForwarder); + + ArrayPtr checks = Array::RawCast(function->untag()->data()); + FunctionPtr target = Function::RawCast(checks->untag()->element(0)); + ASSERT(Function::KindOf(target) != + UntaggedFunction::kDynamicInvocationForwarder); + + // TODO(alexmarkov): add parameter type checks. + + SP[1] = target; + goto TailCallSP1; + } + + { + BYTECODE(VMInternal_NoSuchMethodDispatcher, 0); + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kNoSuchMethodDispatcher); + SP[1] = function; + goto NoSuchMethodFromPrologue; + } + + { + BYTECODE(VMInternal_ImplicitStaticClosure, 0); + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kImplicitClosureFunction); + ClosureDataPtr data = ClosureData::RawCast(function->untag()->data()); + FunctionPtr target = Function::RawCast(data->untag()->parent_function()); + + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ObjectPtr* argv = FrameArguments(FP, argc); + + if (type_args_len > 0) { + // Replace closure receiver with type arguments. + argv[1] = argv[0]; + } else if (Function::KindOf(target) == UntaggedFunction::kConstructor) { + // Factory constructors always take type arguments. + FunctionTypePtr signature = + FunctionType::RawCast(function->untag()->signature()); + TypeParametersPtr type_params = signature->untag()->type_parameters(); + TypeArgumentsPtr type_args = (type_params == null_value) + ? TypeArguments::null() + : type_params->untag()->defaults(); + argv[0] = type_args; + } + SP[1] = target; + SP[2] = 0; // Space for result. + SP[3] = argdesc_; + SP[4] = target; + Exit(thread, FP, SP + 5, pc); + INVOKE_RUNTIME(DRT_AdjustArgumentsDesciptorForImplicitClosure, + NativeArguments(thread, 2, SP + 3, SP + 2)); + argdesc_ = Array::RawCast(SP[2]); + + goto TailCallSP1; + } + + { + BYTECODE(VMInternal_ImplicitInstanceClosure, 0); + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kImplicitClosureFunction); + ClosureDataPtr data = ClosureData::RawCast(function->untag()->data()); + FunctionPtr target = Function::RawCast(data->untag()->parent_function()); + + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ObjectPtr* argv = FrameArguments(FP, argc); + + // Replace closure receiver with captured receiver + // and call target function. + ClosurePtr closure = Closure::RawCast(argv[receiver_idx]); + argv[receiver_idx] = closure->untag()->context(); + SP[1] = target; + + goto TailCallSP1; + } + + { + BYTECODE(VMInternal_ImplicitConstructorClosure, 0); + FunctionPtr function = FrameFunction(FP); + ASSERT(Function::KindOf(function) == + UntaggedFunction::kImplicitClosureFunction); + UNIMPLEMENTED(); + DISPATCH(); + } + + { + TailCallSP1: + FunctionPtr function = Function::RawCast(SP[1]); + + for (;;) { + if (Function::HasBytecode(function)) { + ASSERT(function->IsFunction()); + BytecodePtr bytecode = Function::GetBytecode(function); + ASSERT(bytecode->IsBytecode()); + FP[kKBCFunctionSlotFromFp] = function; + FP[kKBCPcMarkerSlotFromFp] = bytecode; + pp_ = bytecode->untag()->object_pool(); + pc = + reinterpret_cast(bytecode->untag()->instructions_); + NOT_IN_PRODUCT(pc_ = pc); // For the profiler. + DISPATCH(); + } + + if (Function::HasCode(function)) { + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ObjectPtr* argv = FrameArguments(FP, argc); + for (intptr_t i = 0; i < argc; i++) { + *++SP = argv[i]; + } + + ObjectPtr* call_base = SP - argc + 1; + ObjectPtr* call_top = SP + 1; + call_top[0] = function; + if (!InvokeCompiled(thread, function, call_base, call_top, &pc, &FP, + &SP)) { + HANDLE_EXCEPTION; + } else { + HANDLE_RETURN; + } + DISPATCH(); + } + + // Compile the function to either generate code or load bytecode. + SP[1] = argdesc_; + SP[2] = 0; // Code result. + SP[3] = function; + Exit(thread, FP, SP + 4, pc); + if (!InvokeRuntime(thread, this, DRT_CompileFunction, + NativeArguments(thread, 1, /* argv */ SP + 3, + /* retval */ SP + 2))) { + HANDLE_EXCEPTION; + } + function = Function::RawCast(SP[3]); + argdesc_ = Array::RawCast(SP[1]); + + ASSERT(Function::HasCode(function)); + } + } + + // Helper used to handle noSuchMethod on closures. The function should be + // placed into SP[1] before jumping here, similar to TailCallSP1. + { + NoSuchMethodFromPrologue: + FunctionPtr function = Function::RawCast(SP[1]); + + const intptr_t type_args_len = + InterpreterHelpers::ArgDescTypeArgsLen(argdesc_); + const intptr_t receiver_idx = type_args_len > 0 ? 1 : 0; + const intptr_t argc = + InterpreterHelpers::ArgDescArgCount(argdesc_) + receiver_idx; + ObjectPtr* args = FrameArguments(FP, argc); + + SP[1] = null_value; + SP[2] = args[receiver_idx]; + SP[3] = function; + SP[4] = argdesc_; + SP[5] = null_value; // Array of arguments (will be filled). + + // Allocate array of arguments. + { + SP[6] = Smi::New(argc); // length + SP[7] = null_value; // type + Exit(thread, FP, SP + 8, pc); + if (!InvokeRuntime(thread, this, DRT_AllocateArray, + NativeArguments(thread, 2, SP + 6, SP + 5))) { + HANDLE_EXCEPTION; + } + + // Copy arguments into the newly allocated array. + ArrayPtr array = static_cast(SP[5]); + ASSERT(array->GetClassId() == kArrayCid); + for (intptr_t i = 0; i < argc; i++) { + array->untag()->set_element(i, args[i], thread); + } + } + + // Invoke noSuchMethod passing down receiver, function, argument descriptor + // and array of arguments. + { + Exit(thread, FP, SP + 6, pc); + INVOKE_RUNTIME(DRT_NoSuchMethodFromPrologue, + NativeArguments(thread, 4, SP + 2, SP + 1)); + ++SP; // Result at SP[0] + } + + DISPATCH(); + } + + { + ThrowNullError: + // SP[0] contains selector. + SP[1] = 0; // Unused space for result. + Exit(thread, FP, SP + 2, pc); + INVOKE_RUNTIME(DRT_NullErrorWithSelector, + NativeArguments(thread, 1, SP, SP + 1)); + UNREACHABLE(); + } + + { + ThrowIntegerDivisionByZeroException: + SP[0] = 0; // Unused space for result. + Exit(thread, FP, SP + 1, pc); + INVOKE_RUNTIME(DRT_IntegerDivisionByZeroException, + NativeArguments(thread, 0, SP, SP)); + UNREACHABLE(); + } + + { + ThrowArgumentError: + // SP[0] contains value. + SP[1] = 0; // Unused space for result. + Exit(thread, FP, SP + 2, pc); + INVOKE_RUNTIME(DRT_ArgumentError, NativeArguments(thread, 1, SP, SP + 1)); + UNREACHABLE(); + } + + // Exception handling helper. Gets handler FP and PC from the Interpreter + // where they were stored by Interpreter::Longjmp and proceeds to execute the + // handler. Corner case: handler PC can be a fake marker that marks entry + // frame, which means exception was not handled in the interpreter. In this + // case we return the caught exception from Interpreter::Call. + { + HandleException: + FP = fp_; + pc = pc_; + if (IsEntryFrameMarker(pc)) { + pp_ = static_cast(fp_[kKBCSavedPpSlotFromEntryFp]); + argdesc_ = static_cast(fp_[kKBCSavedArgDescSlotFromEntryFp]); + uword exit_fp = static_cast(fp_[kKBCExitLinkSlotFromEntryFp]); + thread->set_top_exit_frame_info(exit_fp); + thread->set_top_resource(top_resource); + thread->set_vm_tag(vm_tag); +#if defined(DEBUG) + if (IsTracingExecution()) { + THR_Print("%" Pu64 " ", icount_); + THR_Print("Returning exception from interpreter 0x%" Px " at fp_ 0x%" Px + " exit 0x%" Px "\n", + reinterpret_cast(this), reinterpret_cast(fp_), + exit_fp); + } +#endif + ASSERT(HasFrame(reinterpret_cast(fp_))); + return special_[KernelBytecode::kExceptionSpecialIndex]; + } + + pp_ = InterpreterHelpers::FrameBytecode(FP)->untag()->object_pool(); + DISPATCH(); + } + + UNREACHABLE(); + return 0; +} + +void Interpreter::JumpToFrame(uword pc, uword sp, uword fp, Thread* thread) { + // Walk over all setjmp buffers (simulated --> C++ transitions) + // and try to find the setjmp associated with the simulated frame pointer. + InterpreterSetjmpBuffer* buf = last_setjmp_buffer(); + while ((buf->link() != NULL) && (buf->link()->fp() > fp)) { + buf = buf->link(); + } + ASSERT(buf != NULL); + ASSERT(last_setjmp_buffer() == buf); + + // The C++ caller has not cleaned up the stack memory of C++ frames. + // Prepare for unwinding frames by destroying all the stack resources + // in the previous C++ frames. + StackResource::Unwind(thread); + + fp_ = reinterpret_cast(fp); + + if (pc == StubCode::RunExceptionHandler().EntryPoint()) { + // The RunExceptionHandler stub is a placeholder. We implement + // its behavior here. + ObjectPtr raw_exception = thread->active_exception(); + ObjectPtr raw_stacktrace = thread->active_stacktrace(); + ASSERT(raw_exception != Object::null()); + thread->set_active_exception(Object::null_object()); + thread->set_active_stacktrace(Object::null_object()); + special_[KernelBytecode::kExceptionSpecialIndex] = raw_exception; + special_[KernelBytecode::kStackTraceSpecialIndex] = raw_stacktrace; + pc_ = reinterpret_cast(thread->resume_pc()); + } else { + pc_ = reinterpret_cast(pc); + } + + // Set the tag. + thread->set_vm_tag(VMTag::kDartInterpretedTagId); + // Clear top exit frame. + thread->set_top_exit_frame_info(0); + + buf->Longjmp(); + UNREACHABLE(); +} + +void Interpreter::VisitObjectPointers(ObjectPointerVisitor* visitor) { + visitor->VisitPointer(reinterpret_cast(&pp_)); + visitor->VisitPointer(reinterpret_cast(&argdesc_)); +} + +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) diff --git a/runtime/vm/interpreter.h b/runtime/vm/interpreter.h new file mode 100644 index 00000000000..568340305fc --- /dev/null +++ b/runtime/vm/interpreter.h @@ -0,0 +1,271 @@ +// Copyright (c) 2024, 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_INTERPRETER_H_ +#define RUNTIME_VM_INTERPRETER_H_ + +#include "vm/globals.h" +#if defined(DART_DYNAMIC_MODULES) + +#include "vm/compiler/method_recognizer.h" +#include "vm/constants_kbc.h" +#include "vm/tagged_pointer.h" + +namespace dart { + +class Array; +class Code; +class InterpreterSetjmpBuffer; +class Isolate; +class ObjectPointerVisitor; +class Thread; + +class LookupCache : public ValueObject { + public: + LookupCache() { + ASSERT(Utils::IsPowerOfTwo(sizeof(Entry))); + ASSERT(Utils::IsPowerOfTwo(sizeof(kNumEntries))); + Clear(); + } + + void Clear(); + bool Lookup(intptr_t receiver_cid, + StringPtr function_name, + ArrayPtr arguments_descriptor, + FunctionPtr* target) const; + void Insert(intptr_t receiver_cid, + StringPtr function_name, + ArrayPtr arguments_descriptor, + FunctionPtr target); + + private: + struct Entry { + intptr_t receiver_cid; + StringPtr function_name; + ArrayPtr arguments_descriptor; + FunctionPtr target; + }; + + static const intptr_t kNumEntries = 1024; + static const intptr_t kTableMask = kNumEntries - 1; + + Entry entries_[kNumEntries]; +}; + +class Interpreter { + public: + static const uword kInterpreterStackUnderflowSize = 0x80; + // The entry frame pc marker must be non-zero (a valid exception handler pc). + static const word kEntryFramePcMarker = -1; + + Interpreter(); + ~Interpreter(); + + // The currently executing Interpreter instance, which is associated to the + // current isolate + static Interpreter* Current(); + + // Low address (KBC stack grows up). + uword stack_base() const { return stack_base_; } + // Limit for StackOverflowError. + uword overflow_stack_limit() const { return overflow_stack_limit_; } + // High address (KBC stack grows up). + uword stack_limit() const { return stack_limit_; } + + // Returns true if the interpreter's stack contains the given frame. + // TODO(regis): We should rely on a new thread vm_tag to identify an + // interpreter frame and not need this HasFrame() method. + bool HasFrame(uword frame) const { + return frame >= stack_base() && frame < stack_limit(); + } + + // Identify an entry frame by looking at its pc marker value. + static bool IsEntryFrameMarker(const KBCInstr* pc) { + return reinterpret_cast(pc) == kEntryFramePcMarker; + } + + ObjectPtr Call(const Function& function, + const Array& arguments_descriptor, + const Array& arguments, + Thread* thread); + + ObjectPtr Call(FunctionPtr function, + ArrayPtr argdesc, + intptr_t argc, + ObjectPtr const* argv, + ArrayPtr args_array, + Thread* thread); + + void JumpToFrame(uword pc, uword sp, uword fp, Thread* thread); + + uword get_sp() const { return reinterpret_cast(fp_); } // Yes, fp_. + uword get_fp() const { return reinterpret_cast(fp_); } + uword get_pc() const { return reinterpret_cast(pc_); } + + void Unexit(Thread* thread); + + void VisitObjectPointers(ObjectPointerVisitor* visitor); + void ClearLookupCache() { lookup_cache_.Clear(); } + +#ifndef PRODUCT + void set_is_debugging(bool value) { is_debugging_ = value; } + bool is_debugging() const { return is_debugging_; } +#endif // !PRODUCT + + private: + uintptr_t* stack_; + uword stack_base_; + uword overflow_stack_limit_; + uword stack_limit_; + + ObjectPtr* volatile fp_; + const KBCInstr* volatile pc_; + DEBUG_ONLY(uint64_t icount_;) + + InterpreterSetjmpBuffer* last_setjmp_buffer_; + + ObjectPoolPtr pp_; // Pool Pointer. + ArrayPtr argdesc_; // Arguments Descriptor: used to pass information between + // call instruction and the function entry. + ObjectPtr special_[KernelBytecode::kSpecialIndexCount]; + + LookupCache lookup_cache_; + + void Exit(Thread* thread, + ObjectPtr* base, + ObjectPtr* exit_frame, + const KBCInstr* pc); + + bool Invoke(Thread* thread, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP); + + bool InvokeCompiled(Thread* thread, + FunctionPtr function, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP); + + bool InvokeBytecode(Thread* thread, + FunctionPtr function, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP); + + bool InstanceCall(Thread* thread, + StringPtr target_name, + ObjectPtr* call_base, + ObjectPtr* call_top, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP); + + bool CopyParameters(Thread* thread, + const KBCInstr** pc, + ObjectPtr** FP, + ObjectPtr** SP, + const intptr_t num_fixed_params, + const intptr_t num_opt_pos_params, + const intptr_t num_opt_named_params, + const intptr_t num_reserved_locals); + + bool AssertAssignable(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* call_top, + ObjectPtr* args, + SubtypeTestCachePtr cache); + template + bool AssertAssignableField(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP, + InstancePtr instance, + FieldPtr field, + InstancePtr value); + + bool AllocateMint(Thread* thread, + int64_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateDouble(Thread* thread, + double value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateFloat32x4(Thread* thread, + simd128_value_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateFloat64x2(Thread* thread, + simd128_value_t value, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateArray(Thread* thread, + TypeArgumentsPtr type_args, + ObjectPtr length, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateContext(Thread* thread, + intptr_t num_variables, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + bool AllocateClosure(Thread* thread, + const KBCInstr* pc, + ObjectPtr* FP, + ObjectPtr* SP); + +#if defined(DEBUG) + // Returns true if tracing of executed instructions is enabled. + bool IsTracingExecution() const; + + // Prints bytecode instruction at given pc for instruction tracing. + void TraceInstruction(const KBCInstr* pc) const; + + bool IsWritingTraceFile() const; + void FlushTraceBuffer(); + void WriteInstructionToTrace(const KBCInstr* pc); + + void* trace_file_; + uint64_t trace_file_bytes_written_; + + static const intptr_t kTraceBufferSizeInBytes = 10 * KB; + static const intptr_t kTraceBufferInstrs = + kTraceBufferSizeInBytes / sizeof(KBCInstr); + KBCInstr* trace_buffer_; + intptr_t trace_buffer_idx_; +#endif // defined(DEBUG) + + // Longjmp support for exceptions. + InterpreterSetjmpBuffer* last_setjmp_buffer() { return last_setjmp_buffer_; } + void set_last_setjmp_buffer(InterpreterSetjmpBuffer* buffer) { + last_setjmp_buffer_ = buffer; + } + +#ifndef PRODUCT + bool is_debugging_ = false; +#endif // !PRODUCT + + friend class InterpreterSetjmpBuffer; + + DISALLOW_COPY_AND_ASSIGN(Interpreter); +}; + +} // namespace dart + +#endif // defined(DART_DYNAMIC_MODULES) + +#endif // RUNTIME_VM_INTERPRETER_H_ diff --git a/runtime/vm/isolate.h b/runtime/vm/isolate.h index 33637f5ce8a..7e6328a978f 100644 --- a/runtime/vm/isolate.h +++ b/runtime/vm/isolate.h @@ -530,9 +530,9 @@ class IsolateGroup : public IntrusiveDListEntry { Mutex* unlinked_call_map_mutex() { return &unlinked_call_map_mutex_; } #endif -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) Mutex* initializer_functions_mutex() { return &initializer_functions_mutex_; } -#endif // !defined(DART_PRECOMPILED_RUNTIME) +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) SafepointRwLock* program_lock() { return program_lock_.get(); } @@ -907,9 +907,9 @@ class IsolateGroup : public IntrusiveDListEntry { Mutex unlinked_call_map_mutex_; #endif -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) Mutex initializer_functions_mutex_; -#endif // !defined(DART_PRECOMPILED_RUNTIME) +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) // Protect access to boxed_field_list_. Mutex field_list_mutex_; diff --git a/runtime/vm/kernel_loader.cc b/runtime/vm/kernel_loader.cc index d3034820e24..befaeec05cc 100644 --- a/runtime/vm/kernel_loader.cc +++ b/runtime/vm/kernel_loader.cc @@ -2387,67 +2387,6 @@ FunctionPtr KernelLoader::GetClosureFunction(Thread* thread, return function.ptr(); } -FunctionPtr CreateFieldInitializerFunction(Thread* thread, - Zone* zone, - const Field& field) { - ASSERT(field.InitializerFunction() == Function::null()); - - String& init_name = String::Handle(zone, field.name()); - init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name); - - // Static field initializers are not added as members of their owning class, - // so they must be preemptively given a patch class to avoid the meaning of - // their kernel/token position changing during a reload. Compare - // Class::PatchFieldsAndFunctions(). - // This might also be necessary for lazy computation of local var descriptors. - // Compare https://codereview.chromium.org//1317753004 - const Script& script = Script::Handle(zone, field.Script()); - const Class& field_owner = Class::Handle(zone, field.Owner()); - const auto& kernel_program_info = - KernelProgramInfo::Handle(zone, field.KernelProgramInfo()); - const PatchClass& initializer_owner = PatchClass::Handle( - zone, PatchClass::New(field_owner, kernel_program_info, script)); - const Library& lib = Library::Handle(zone, field_owner.library()); - initializer_owner.set_kernel_library_index(lib.kernel_library_index()); - - // Create a static initializer. - FunctionType& signature = FunctionType::Handle(zone, FunctionType::New()); - const Function& initializer_fun = Function::Handle( - zone, - Function::New(signature, init_name, UntaggedFunction::kFieldInitializer, - field.is_static(), // is_static - false, // is_const - false, // is_abstract - false, // is_external - false, // is_native - initializer_owner, TokenPosition::kNoSource)); - if (!field.is_static()) { - signature.set_num_fixed_parameters(1); - signature.set_parameter_types( - Array::Handle(zone, Array::New(1, Heap::kOld))); - signature.SetParameterTypeAt( - 0, AbstractType::Handle(zone, field_owner.DeclarationType())); - initializer_fun.CreateNameArray(); - initializer_fun.SetParameterNameAt(0, Symbols::This()); - } - signature.set_result_type(AbstractType::Handle(zone, field.type())); - initializer_fun.set_is_reflectable(false); - initializer_fun.set_is_inlinable(false); - initializer_fun.set_token_pos(field.token_pos()); - initializer_fun.set_end_token_pos(field.end_token_pos()); - initializer_fun.set_accessor_field(field); - initializer_fun.InheritKernelOffsetFrom(field); - initializer_fun.set_is_extension_member(field.is_extension_member()); - initializer_fun.set_is_extension_type_member( - field.is_extension_type_member()); - - signature ^= ClassFinalizer::FinalizeType(signature); - initializer_fun.SetSignature(signature); - - field.SetInitializerFunction(initializer_fun); - return initializer_fun.ptr(); -} - } // namespace kernel } // namespace dart #endif // !defined(DART_PRECOMPILED_RUNTIME) diff --git a/runtime/vm/kernel_loader.h b/runtime/vm/kernel_loader.h index 2bff1bc9343..7cf95640cee 100644 --- a/runtime/vm/kernel_loader.h +++ b/runtime/vm/kernel_loader.h @@ -420,10 +420,6 @@ class KernelLoader : public ValueObject { DISALLOW_COPY_AND_ASSIGN(KernelLoader); }; -FunctionPtr CreateFieldInitializerFunction(Thread* thread, - Zone* zone, - const Field& field); - } // namespace kernel } // namespace dart diff --git a/runtime/vm/native_arguments.h b/runtime/vm/native_arguments.h index e3b7ba8f207..c09640933c9 100644 --- a/runtime/vm/native_arguments.h +++ b/runtime/vm/native_arguments.h @@ -85,7 +85,8 @@ class NativeArguments { ObjectPtr ArgAt(int index) const { ASSERT((index >= 0) && (index < ArgCount())); - ObjectPtr* arg_ptr = &(argv_[-index]); + ObjectPtr* arg_ptr = + &(argv_[ReverseArgOrderBit::decode(argc_tag_) ? index : -index]); // Tell MemorySanitizer the ObjectPtr was initialized (by generated code). MSAN_UNPOISON(arg_ptr, kWordSize); return *arg_ptr; @@ -94,7 +95,7 @@ class NativeArguments { void SetArgAt(int index, const Object& value) const { ASSERT(thread_->execution_state() == Thread::kThreadInVM); ASSERT((index >= 0) && (index < ArgCount())); - argv_[-index] = value.ptr(); + argv_[ReverseArgOrderBit::decode(argc_tag_) ? index : -index] = value.ptr(); } // Does not include hidden type arguments vector. @@ -198,14 +199,30 @@ class NativeArguments { kArgcSize = 24, kFunctionBit = kArgcBit + kArgcSize, kFunctionSize = 1, + kReverseArgOrderBit = kFunctionBit + kFunctionSize, + kReverseArgOrderSize = 1, }; class ArgcBits : public BitField {}; class FunctionBits : public BitField {}; + class ReverseArgOrderBit + : public BitField {}; friend class Api; + friend class Interpreter; friend class NativeEntry; friend class Simulator; +#if defined(DART_DYNAMIC_MODULES) + NativeArguments(Thread* thread, + int argc_tag, + ObjectPtr* argv, + ObjectPtr* retval) + : thread_(thread), + argc_tag_(ReverseArgOrderBit::update(true, argc_tag)), + argv_(argv), + retval_(retval) {} +#endif // defined(DART_DYNAMIC_MODULES) + // Since this function is passed an ObjectPtr directly, we need to be // exceedingly careful when we use it. If there are any other side // effects in the statement that may cause GC, it could lead to diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc index 21350dfb78a..a5bc93ebd35 100644 --- a/runtime/vm/object.cc +++ b/runtime/vm/object.cc @@ -16,6 +16,7 @@ #include "platform/unicode.h" #include "vm/bit_vector.h" #include "vm/bootstrap.h" +#include "vm/bytecode_reader.h" #include "vm/canonical_tables.h" #include "vm/class_finalizer.h" #include "vm/class_id.h" @@ -24,6 +25,7 @@ #include "vm/code_descriptors.h" #include "vm/code_observers.h" #include "vm/compiler/assembler/disassembler.h" +#include "vm/compiler/assembler/disassembler_kbc.h" #include "vm/compiler/jit/compiler.h" #include "vm/compiler/runtime_api.h" #include "vm/cpu.h" @@ -173,6 +175,7 @@ ClassPtr Object::var_descriptors_class_ = static_cast(RAW_NULL); ClassPtr Object::exception_handlers_class_ = static_cast(RAW_NULL); ClassPtr Object::context_class_ = static_cast(RAW_NULL); ClassPtr Object::context_scope_class_ = static_cast(RAW_NULL); +ClassPtr Object::bytecode_class_ = static_cast(RAW_NULL); ClassPtr Object::sentinel_class_ = static_cast(RAW_NULL); ClassPtr Object::singletargetcache_class_ = static_cast(RAW_NULL); ClassPtr Object::unlinkedcall_class_ = static_cast(RAW_NULL); @@ -551,6 +554,23 @@ static type SpecialCharacter(type value) { return '\0'; } +#if defined(DART_DYNAMIC_MODULES) +static BytecodePtr CreateVMInternalBytecode(KernelBytecode::Opcode opcode) { + const KBCInstr* instructions = nullptr; + intptr_t instructions_size = 0; + + KernelBytecode::GetVMInternalBytecodeInstructions(opcode, &instructions, + &instructions_size); + + const auto& bytecode = Bytecode::Handle( + Bytecode::New(reinterpret_cast(instructions), instructions_size, + -1, TypedDataBase::Handle(), Object::empty_object_pool())); + bytecode.set_pc_descriptors(Object::empty_descriptors()); + bytecode.set_exception_handlers(Object::empty_exception_handlers()); + return bytecode.ptr(); +} +#endif // defined(DART_DYNAMIC_MODULES) + void Object::InitNullAndBool(IsolateGroup* isolate_group) { // Should only be run by the vm isolate. ASSERT(isolate_group == Dart::vm_isolate_group()); @@ -912,6 +932,9 @@ void Object::Init(IsolateGroup* isolate_group) { cls = Class::New(isolate_group); context_scope_class_ = cls.ptr(); + cls = Class::New(isolate_group); + bytecode_class_ = cls.ptr(); + cls = Class::New(isolate_group); singletargetcache_class_ = cls.ptr(); @@ -1270,6 +1293,41 @@ void Object::Init(IsolateGroup* isolate_group) { // synthetic_getter_parameter_names_ object needs to be created earlier as // VM isolate snapshot reader references it before Object::FinalizeVMIsolate. +#if defined(DART_DYNAMIC_MODULES) + *implicit_getter_bytecode_ = + CreateVMInternalBytecode(KernelBytecode::kVMInternal_ImplicitGetter); + + *implicit_setter_bytecode_ = + CreateVMInternalBytecode(KernelBytecode::kVMInternal_ImplicitSetter); + + *implicit_static_getter_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_ImplicitStaticGetter); + + *method_extractor_bytecode_ = + CreateVMInternalBytecode(KernelBytecode::kVMInternal_MethodExtractor); + + *invoke_closure_bytecode_ = + CreateVMInternalBytecode(KernelBytecode::kVMInternal_InvokeClosure); + + *invoke_field_bytecode_ = + CreateVMInternalBytecode(KernelBytecode::kVMInternal_InvokeField); + + *nsm_dispatcher_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_NoSuchMethodDispatcher); + + *dynamic_invocation_forwarder_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_ForwardDynamicInvocation); + + *implicit_static_closure_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_ImplicitStaticClosure); + + *implicit_instance_closure_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_ImplicitInstanceClosure); + + *implicit_constructor_closure_bytecode_ = CreateVMInternalBytecode( + KernelBytecode::kVMInternal_ImplicitConstructorClosure); +#endif // defined(DART_DYNAMIC_MODULES) + // Some thread fields need to be reinitialized as null constants have not been // initialized until now. thread->ClearStickyError(); @@ -1347,6 +1405,28 @@ void Object::Init(IsolateGroup* isolate_group) { ASSERT(synthetic_getter_parameter_types_->IsArray()); ASSERT(!synthetic_getter_parameter_names_->IsSmi()); ASSERT(synthetic_getter_parameter_names_->IsArray()); + ASSERT(!implicit_getter_bytecode_->IsSmi()); + ASSERT(implicit_getter_bytecode_->IsBytecode()); + ASSERT(!implicit_setter_bytecode_->IsSmi()); + ASSERT(implicit_setter_bytecode_->IsBytecode()); + ASSERT(!implicit_static_getter_bytecode_->IsSmi()); + ASSERT(implicit_static_getter_bytecode_->IsBytecode()); + ASSERT(!method_extractor_bytecode_->IsSmi()); + ASSERT(method_extractor_bytecode_->IsBytecode()); + ASSERT(!invoke_closure_bytecode_->IsSmi()); + ASSERT(invoke_closure_bytecode_->IsBytecode()); + ASSERT(!invoke_field_bytecode_->IsSmi()); + ASSERT(invoke_field_bytecode_->IsBytecode()); + ASSERT(!nsm_dispatcher_bytecode_->IsSmi()); + ASSERT(nsm_dispatcher_bytecode_->IsBytecode()); + ASSERT(!dynamic_invocation_forwarder_bytecode_->IsSmi()); + ASSERT(dynamic_invocation_forwarder_bytecode_->IsBytecode()); + ASSERT(!implicit_static_closure_bytecode_->IsSmi()); + ASSERT(implicit_static_closure_bytecode_->IsBytecode()); + ASSERT(!implicit_instance_closure_bytecode_->IsSmi()); + ASSERT(implicit_instance_closure_bytecode_->IsBytecode()); + ASSERT(!implicit_constructor_closure_bytecode_->IsSmi()); + ASSERT(implicit_constructor_closure_bytecode_->IsBytecode()); } void Object::FinishInit(IsolateGroup* isolate_group) { @@ -1392,6 +1472,7 @@ void Object::Cleanup() { exception_handlers_class_ = static_cast(RAW_NULL); context_class_ = static_cast(RAW_NULL); context_scope_class_ = static_cast(RAW_NULL); + bytecode_class_ = static_cast(RAW_NULL); singletargetcache_class_ = static_cast(RAW_NULL); unlinkedcall_class_ = static_cast(RAW_NULL); monomorphicsmiablecall_class_ = static_cast(RAW_NULL); @@ -1509,6 +1590,7 @@ void Object::FinalizeVMIsolate(IsolateGroup* isolate_group) { SET_CLASS_NAME(exception_handlers, ExceptionHandlers); SET_CLASS_NAME(context, Context); SET_CLASS_NAME(context_scope, ContextScope); + SET_CLASS_NAME(bytecode, Bytecode); SET_CLASS_NAME(sentinel, Sentinel); SET_CLASS_NAME(singletargetcache, SingleTargetCache); SET_CLASS_NAME(unlinkedcall, UnlinkedCall); @@ -3105,7 +3187,7 @@ ClassPtr Class::New(IsolateGroup* isolate_group, bool register_class) { return result.ptr(); } -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) static void ReportTooManyTypeArguments(const Class& cls) { Report::MessageF(Report::kError, Script::Handle(cls.script()), cls.token_pos(), Report::AtLocation, @@ -3114,10 +3196,10 @@ static void ReportTooManyTypeArguments(const Class& cls) { String::Handle(cls.Name()).ToCString()); UNREACHABLE(); } -#endif // !defined(DART_PRECOMPILED_RUNTIME) +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) void Class::set_num_type_arguments(intptr_t value) const { -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); #else if (!Utils::IsInt(16, value)) { @@ -3129,7 +3211,7 @@ void Class::set_num_type_arguments(intptr_t value) const { DEBUG_ASSERT(old_value == kUnknownNumTypeArguments || old_value == value); StoreNonPointer( &untag()->num_type_arguments_, value); -#endif // defined(DART_PRECOMPILED_RUNTIME) +#endif // defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) } void Class::set_num_type_arguments_unsafe(intptr_t value) const { @@ -3451,7 +3533,7 @@ void Class::set_library(const Library& value) const { void Class::set_type_parameters(const TypeParameters& value) const { ASSERT((num_type_arguments() == kUnknownNumTypeArguments) || - is_prefinalized()); + is_declared_in_bytecode() || is_prefinalized()); untag()->set_type_parameters(value.ptr()); } @@ -3966,6 +4048,26 @@ FunctionPtr Class::CreateInvocationDispatcher( signature ^= ClassFinalizer::FinalizeType(signature); invocation.SetSignature(signature); +#if defined(DART_DYNAMIC_MODULES) +#if defined(DART_PRECOMPILED_RUNTIME) + const bool attach_bytecode = true; +#else + const bool attach_bytecode = is_declared_in_bytecode(); +#endif + if (attach_bytecode) { + switch (kind) { + case UntaggedFunction::kNoSuchMethodDispatcher: + invocation.AttachBytecode(Object::nsm_dispatcher_bytecode()); + break; + case UntaggedFunction::kInvokeFieldDispatcher: + invocation.AttachBytecode(Object::invoke_field_bytecode()); + break; + default: + UNREACHABLE(); + } + } +#endif // defined(DART_DYNAMIC_MODULES) + return invocation.ptr(); } @@ -4015,6 +4117,17 @@ FunctionPtr Function::CreateMethodExtractor(const String& getter_name) const { signature ^= ClassFinalizer::FinalizeType(signature); extractor.SetSignature(signature); +#if defined(DART_DYNAMIC_MODULES) +#if defined(DART_PRECOMPILED_RUNTIME) + const bool attach_bytecode = true; +#else + const bool attach_bytecode = is_declared_in_bytecode(); +#endif + if (attach_bytecode) { + extractor.AttachBytecode(Object::method_extractor_bytecode()); + } +#endif // defined(DART_DYNAMIC_MODULES) + owner.AddFunction(extractor); return extractor.ptr(); @@ -4216,7 +4329,7 @@ StringPtr Function::CreateDynamicInvocationForwarderName(const String& name) { return Symbols::FromConcat(Thread::Current(), Symbols::DynamicPrefix(), name); } -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) FunctionPtr Function::CreateDynamicInvocationForwarder( const String& mangled_name) const { Thread* thread = Thread::Current(); @@ -4252,6 +4365,17 @@ FunctionPtr Function::CreateDynamicInvocationForwarder( forwarder.InheritKernelOffsetFrom(*this); forwarder.SetForwardingTarget(*this); +#if defined(DART_DYNAMIC_MODULES) +#if defined(DART_PRECOMPILED_RUNTIME) + const bool attach_bytecode = true; +#else + const bool attach_bytecode = is_declared_in_bytecode(); +#endif + if (attach_bytecode) { + forwarder.AttachBytecode(Object::dynamic_invocation_forwarder_bytecode()); + } +#endif + return forwarder.ptr(); } @@ -4271,7 +4395,12 @@ FunctionPtr Function::GetDynamicInvocationForwarder( if (!result.IsNull()) return result.ptr(); const bool needs_dyn_forwarder = +#if defined(DART_DYNAMIC_MODULES) && defined(DART_PRECOMPILED_RUNTIME) + // TODO(alexmarkov) + false; +#else kernel::NeedsDynamicInvocationForwarder(*this); +#endif if (!needs_dyn_forwarder) { return ptr(); } @@ -4292,6 +4421,22 @@ FunctionPtr Function::GetDynamicInvocationForwarder( return result.ptr(); } +void Function::ReadParameterCovariance( + BitVector* is_covariant, + BitVector* is_generic_covariant_impl) const { +#if defined(DART_DYNAMIC_MODULES) + if (is_declared_in_bytecode()) { + bytecode::BytecodeReader::ReadParameterCovariance( + *this, is_covariant, is_generic_covariant_impl); + return; + } +#endif +#if !defined(DART_PRECOMPILED_RUNTIME) + kernel::ReadParameterCovariance(*this, is_covariant, + is_generic_covariant_impl); +#endif +} + #endif bool AbstractType::InstantiateAndTestSubtype( @@ -4922,11 +5067,21 @@ ObjectPtr Instance::EvaluateCompiledExpression( void Class::EnsureDeclarationLoaded() const { if (!is_declaration_loaded()) { +#if defined(DART_DYNAMIC_MODULES) + // Loading of class declaration can be postponed until needed + // if class comes from bytecode. + if (is_declared_in_bytecode()) { + bytecode::BytecodeReader::LoadClassDeclaration(*this); + ASSERT(is_declaration_loaded()); + ASSERT(is_type_finalized()); + return; + } +#endif // defined(DART_DYNAMIC_MODULES) #if defined(DART_PRECOMPILED_RUNTIME) UNREACHABLE(); #else FATAL("Unable to use class %s which is not loaded yet.", ToCString()); -#endif +#endif // defined(DART_PRECOMPILED_RUNTIME) } } @@ -4936,7 +5091,7 @@ ErrorPtr Class::EnsureIsFinalized(Thread* thread) const { if (is_finalized()) { return Error::null(); } -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); return Error::null(); #else @@ -4956,7 +5111,7 @@ ErrorPtr Class::EnsureIsFinalized(Thread* thread) const { } } return error.ptr(); -#endif // defined(DART_PRECOMPILED_RUNTIME) +#endif // defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) } // Ensure that code outdated by finalized class is cleaned up, new instance of @@ -5497,6 +5652,8 @@ const char* Class::GenerateUserVisibleName() const { return Symbols::WeakArray().ToCString(); case kCodeCid: return Symbols::Code().ToCString(); + case kBytecodeCid: + return Symbols::Bytecode().ToCString(); case kInstructionsCid: return Symbols::Instructions().ToCString(); case kInstructionsSectionCid: @@ -5621,6 +5778,9 @@ uint32_t Class::Hash(ClassPtr obj) { int32_t Class::SourceFingerprint() const { #if !defined(DART_PRECOMPILED_RUNTIME) + if (is_declared_in_bytecode()) { + return 0; + } return kernel::KernelSourceFingerprintHelper::CalculateClassFingerprint( *this); #else @@ -5729,6 +5889,13 @@ void Class::set_is_loaded(bool value) const { set_state_bits(IsLoadedBit::update(value, state_bits())); } +#if defined(DART_DYNAMIC_MODULES) +void Class::set_is_declared_in_bytecode(bool value) const { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + set_state_bits(IsDeclaredInBytecodeBit::update(value, state_bits())); +} +#endif // defined(DART_DYNAMIC_MODULES) + void Class::set_is_finalized() const { ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); ASSERT(!is_finalized()); @@ -7957,6 +8124,24 @@ bool Function::HasCode() const { return untag()->code() != StubCode::LazyCompile().ptr(); } +#if defined(DART_DYNAMIC_MODULES) + +void Function::AttachBytecode(const Bytecode& value) const { + ASSERT(IsolateGroup::Current()->program_lock()->IsCurrentThreadWriter()); + ASSERT(!value.IsNull()); + // Finish setting up code before activating it. + if (!value.InVMIsolateHeap()) { + value.set_function(*this); + } + ASSERT(untag()->ic_data_array_or_bytecode() == Object::null()); + untag()->set_ic_data_array_or_bytecode(value.ptr()); + + // Set the code entry_point to InterpretCall stub. + SetInstructions(StubCode::InterpretCall()); +} + +#endif // defined(DART_DYNAMIC_MODULES) + bool Function::HasCode(FunctionPtr function) { NoSafepointScope no_safepoint; ASSERT(function->untag()->code() != Code::null()); @@ -8681,7 +8866,7 @@ StringPtr FunctionType::ParameterNameAt(intptr_t index) const { void FunctionType::SetParameterNameAt(intptr_t index, const String& value) const { -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); #else ASSERT(!value.IsNull() && value.IsSymbol()); @@ -8716,7 +8901,7 @@ void Function::CreateNameArray(Heap::Space space) const { } void FunctionType::CreateNameArrayIncludingFlags(Heap::Space space) const { -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); #else const intptr_t num_named_parameters = NumOptionalNamedParameters(); @@ -10281,7 +10466,7 @@ FunctionPtr Function::New(const FunctionType& signature, ASSERT(!signature.IsNull()); const Function& result = Function::Handle(Function::New(space)); result.set_kind_tag(0); - result.set_packed_fields(0); + NOT_IN_PRECOMPILED(result.set_packed_fields(0)); result.set_name(name); result.set_kind_tag(0); // Ensure determinism of uninitialized bits. result.set_kind(kind); @@ -10309,7 +10494,7 @@ FunctionPtr Function::New(const FunctionType& signature, NOT_IN_PRECOMPILED(result.set_optimized_call_site_count(0)); NOT_IN_PRECOMPILED(result.set_inlining_depth(0)); NOT_IN_PRECOMPILED(result.set_kernel_offset(0)); - result.set_is_optimizable(is_native ? false : true); + NOT_IN_PRECOMPILED(result.set_is_optimizable(is_native ? false : true)); result.set_is_inlinable(true); result.reset_unboxed_parameters_and_return(); result.SetInstructionsSafe(StubCode::LazyCompile()); @@ -10414,7 +10599,7 @@ FunctionPtr Function::ImplicitClosureFunction() const { return implicit_closure_function(); } -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) // In AOT mode all implicit closures are pre-created. FATAL("Cannot create implicit closure in AOT!"); return Function::null(); @@ -10434,6 +10619,7 @@ FunctionPtr Function::ImplicitClosureFunction() const { zone, NewImplicitClosureFunction(closure_name, *this, token_pos())); // Set closure function's context scope. +#if !defined(DART_PRECOMPILED_RUNTIME) if (is_static() || IsConstructor()) { closure_function.set_context_scope(Object::empty_context_scope()); } else { @@ -10441,6 +10627,7 @@ FunctionPtr Function::ImplicitClosureFunction() const { zone, LocalScope::CreateImplicitClosureScope(*this)); closure_function.set_context_scope(context_scope); } +#endif FunctionType& closure_signature = FunctionType::Handle(zone, closure_function.signature()); @@ -10548,7 +10735,7 @@ FunctionPtr Function::ImplicitClosureFunction() const { closure_signature.set_result_type(result_type); // Set closure function's end token to this end token. - closure_function.set_end_token_pos(end_token_pos()); + NOT_IN_PRECOMPILED(closure_function.set_end_token_pos(end_token_pos())); // The closurized method stub just calls into the original method and should // therefore be skipped by the debugger and in stack traces. @@ -10571,21 +10758,22 @@ FunctionPtr Function::ImplicitClosureFunction() const { has_opt_pos_params); closure_signature.set_parameter_types( Array::Handle(zone, Array::New(num_params, Heap::kOld))); - closure_function.CreateNameArray(); + NOT_IN_PRECOMPILED(closure_function.CreateNameArray()); closure_signature.CreateNameArrayIncludingFlags(); AbstractType& param_type = AbstractType::Handle(zone); String& param_name = String::Handle(zone); // Add implicit closure object parameter. param_type = Type::DynamicType(); closure_signature.SetParameterTypeAt(0, param_type); - closure_function.SetParameterNameAt(0, Symbols::ClosureParameter()); + NOT_IN_PRECOMPILED( + closure_function.SetParameterNameAt(0, Symbols::ClosureParameter())); for (int i = kClosure; i < num_pos_params; i++) { param_type = ParameterTypeAt(num_implicit_params - kClosure + i); transform_type(param_type); closure_signature.SetParameterTypeAt(i, param_type); param_name = ParameterNameAt(num_implicit_params - kClosure + i); // Set the name in the function for positional parameters. - closure_function.SetParameterNameAt(i, param_name); + NOT_IN_PRECOMPILED(closure_function.SetParameterNameAt(i, param_name)); } for (int i = num_pos_params; i < num_params; i++) { param_type = ParameterTypeAt(num_implicit_params - kClosure + i); @@ -10605,8 +10793,7 @@ FunctionPtr Function::ImplicitClosureFunction() const { // Change covariant parameter types to Object?. BitVector is_covariant(zone, NumParameters()); BitVector is_generic_covariant_impl(zone, NumParameters()); - kernel::ReadParameterCovariance(*this, &is_covariant, - &is_generic_covariant_impl); + ReadParameterCovariance(&is_covariant, &is_generic_covariant_impl); ObjectStore* object_store = IsolateGroup::Current()->object_store(); const auto& object_type = @@ -10620,6 +10807,27 @@ FunctionPtr Function::ImplicitClosureFunction() const { } } } + +#if defined(DART_DYNAMIC_MODULES) +#if defined(DART_PRECOMPILED_RUNTIME) + const bool attach_bytecode = true; +#else + const bool attach_bytecode = is_declared_in_bytecode(); +#endif + if (attach_bytecode) { + if (is_static()) { + closure_function.AttachBytecode( + Object::implicit_static_closure_bytecode()); + } else if (IsConstructor()) { + closure_function.AttachBytecode( + Object::implicit_constructor_closure_bytecode()); + } else { + closure_function.AttachBytecode( + Object::implicit_instance_closure_bytecode()); + } + } +#endif + ASSERT(!closure_signature.IsFinalized()); closure_signature ^= ClassFinalizer::FinalizeType(closure_signature); closure_function.SetSignature(closure_signature); @@ -10874,9 +11082,17 @@ ClassPtr Function::Owner() const { return PatchClass::Cast(obj).wrapped_class(); } +#if defined(DART_DYNAMIC_MODULES) +bool Function::is_declared_in_bytecode() const { + return Class::Handle(Owner()).is_declared_in_bytecode(); +} +#endif + void Function::InheritKernelOffsetFrom(const Function& src) const { #if defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); +#endif #else StoreNonPointer(&untag()->kernel_offset_, src.untag()->kernel_offset_); #endif @@ -10884,7 +11100,9 @@ void Function::InheritKernelOffsetFrom(const Function& src) const { void Function::InheritKernelOffsetFrom(const Field& src) const { #if defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); +#endif #else set_kernel_offset(src.kernel_offset()); #endif @@ -10972,6 +11190,7 @@ intptr_t Function::KernelLibraryOffset() const { } intptr_t Function::KernelLibraryIndex() const { + ASSERT(!is_declared_in_bytecode()); if (IsNoSuchMethodDispatcher() || IsInvokeFieldDispatcher() || IsFfiCallbackTrampoline()) { return -1; @@ -11194,6 +11413,9 @@ StringPtr Function::GetSource() const { // arguments. int32_t Function::SourceFingerprint() const { #if !defined(DART_PRECOMPILED_RUNTIME) + if (is_declared_in_bytecode()) { + return 0; + } return kernel::KernelSourceFingerprintHelper::CalculateFunctionFingerprint( *this); #else @@ -11292,11 +11514,22 @@ ArrayPtr Function::GetCoverageArray() const { } void Function::set_ic_data_array(const Array& value) const { - untag()->set_ic_data_array(value.ptr()); +#if defined(DART_DYNAMIC_MODULES) + ASSERT(!HasBytecode()); +#endif + untag()->set_ic_data_array_or_bytecode( + value.ptr()); } ArrayPtr Function::ic_data_array() const { - return untag()->ic_data_array(); + ObjectPtr value = + untag()->ic_data_array_or_bytecode(); +#if defined(DART_DYNAMIC_MODULES) + if (value->IsBytecode()) { + return Array::null(); + } +#endif + return Array::RawCast(value); } void Function::ClearICDataArray() const { @@ -11350,6 +11583,8 @@ bool Function::CheckSourceFingerprint(int32_t fp, const char* kind) const { return true; // The kernel structure has been altered, skip checking. } + ASSERT(!is_declared_in_bytecode()); + if (SourceFingerprint() != fp) { // This output can be copied into a file, then used with sed // to replace the old values. @@ -11483,6 +11718,12 @@ bool Function::PrologueNeedsArgumentsDescriptor() const { if (HasSavedArgumentsDescriptor()) { return false; } +#if defined(DART_DYNAMIC_MODULES) + // Entering interpreter needs arguments descriptor. + if (is_declared_in_bytecode()) { + return true; + } +#endif // The prologue of those functions need to examine the arg descriptor for // various purposes. return IsGeneric() || HasOptionalParameters(); @@ -11938,6 +12179,12 @@ uint32_t Field::Hash() const { return String::HashRawSymbol(name()); } +#if defined(DART_DYNAMIC_MODULES) +bool Field::is_declared_in_bytecode() const { + return Class::Handle(Owner()).is_declared_in_bytecode(); +} +#endif + void Field::InheritKernelOffsetFrom(const Field& src) const { #if defined(DART_PRECOMPILED_RUNTIME) UNREACHABLE(); @@ -12110,6 +12357,9 @@ FieldPtr Field::Clone(const Field& original) const { int32_t Field::SourceFingerprint() const { #if !defined(DART_PRECOMPILED_RUNTIME) + if (is_declared_in_bytecode()) { + return 0; + } return kernel::KernelSourceFingerprintHelper::CalculateFieldFingerprint( *this); #else @@ -12343,7 +12593,7 @@ FunctionPtr Field::EnsureInitializerFunction() const { Zone* zone = thread->zone(); Function& initializer = Function::Handle(zone, InitializerFunction()); if (initializer.IsNull()) { -#if defined(DART_PRECOMPILED_RUNTIME) +#if defined(DART_PRECOMPILED_RUNTIME) && !defined(DART_DYNAMIC_MODULES) UNREACHABLE(); #else SafepointMutexLocker ml( @@ -12351,17 +12601,82 @@ FunctionPtr Field::EnsureInitializerFunction() const { // Double check after grabbing the lock. initializer = InitializerFunction(); if (initializer.IsNull()) { - initializer = kernel::CreateFieldInitializerFunction(thread, zone, *this); + initializer = CreateFieldInitializerFunction(thread); } #endif } return initializer.ptr(); } -void Field::SetInitializerFunction(const Function& initializer) const { +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) + +FunctionPtr Field::CreateFieldInitializerFunction(Thread* thread) const { + Zone* zone = thread->zone(); + ASSERT(InitializerFunction() == Function::null()); + + String& init_name = String::Handle(zone, name()); + init_name = Symbols::FromConcat(thread, Symbols::InitPrefix(), init_name); + + const auto& field_owner = Class::Handle(zone, Owner()); + #if defined(DART_PRECOMPILED_RUNTIME) - UNREACHABLE(); + const auto& initializer_owner = Class::Handle(zone, field_owner.ptr()); #else + // Static field initializers are not added as members of their owning class, + // so they must be preemptively given a patch class to avoid the meaning of + // their kernel/token position changing during a reload. Compare + // Class::PatchFieldsAndFunctions(). + // This might also be necessary for lazy computation of local var descriptors. + // Compare https://codereview.chromium.org//1317753004 + const auto& script = Script::Handle(zone, Script()); + const auto& kernel_program_info = + KernelProgramInfo::Handle(zone, KernelProgramInfo()); + const auto& initializer_owner = PatchClass::Handle( + zone, PatchClass::New(field_owner, kernel_program_info, script)); + if (!is_declared_in_bytecode()) { + const Library& lib = Library::Handle(zone, field_owner.library()); + initializer_owner.set_kernel_library_index(lib.kernel_library_index()); + } +#endif + + // Create a static initializer. + FunctionType& signature = FunctionType::Handle(zone, FunctionType::New()); + const Function& initializer_fun = Function::Handle( + zone, + Function::New(signature, init_name, UntaggedFunction::kFieldInitializer, + is_static(), // is_static + false, // is_const + false, // is_abstract + false, // is_external + false, // is_native + initializer_owner, TokenPosition::kNoSource)); + if (!is_static()) { + signature.set_num_fixed_parameters(1); + signature.set_parameter_types( + Array::Handle(zone, Array::New(1, Heap::kOld))); + signature.SetParameterTypeAt( + 0, AbstractType::Handle(zone, field_owner.DeclarationType())); + NOT_IN_PRECOMPILED(initializer_fun.CreateNameArray()); + NOT_IN_PRECOMPILED(initializer_fun.SetParameterNameAt(0, Symbols::This())); + } + signature.set_result_type(AbstractType::Handle(zone, type())); + initializer_fun.set_is_reflectable(false); + initializer_fun.set_is_inlinable(false); + NOT_IN_PRECOMPILED(initializer_fun.set_token_pos(token_pos())); + NOT_IN_PRECOMPILED(initializer_fun.set_end_token_pos(end_token_pos())); + initializer_fun.set_accessor_field(*this); + initializer_fun.InheritKernelOffsetFrom(*this); + initializer_fun.set_is_extension_member(is_extension_member()); + initializer_fun.set_is_extension_type_member(is_extension_type_member()); + + signature ^= ClassFinalizer::FinalizeType(signature); + initializer_fun.SetSignature(signature); + + SetInitializerFunction(initializer_fun); + return initializer_fun.ptr(); +} + +void Field::SetInitializerFunction(const Function& initializer) const { ASSERT(IsOriginal()); ASSERT(IsolateGroup::Current() ->initializer_functions_mutex() @@ -12371,9 +12686,10 @@ void Field::SetInitializerFunction(const Function& initializer) const { // accessed without grabbing the lock. untag()->set_initializer_function( initializer.ptr()); -#endif } +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) + bool Field::HasInitializerFunction() const { return untag()->initializer_function() != Function::null(); } @@ -18513,6 +18829,196 @@ void Code::DumpSourcePositions(bool relative_addresses) const { reader.DumpSourcePositions(relative_addresses ? 0 : PayloadStart()); } +void Bytecode::Disassemble(DisassemblyFormatter* formatter) const { +#if !defined(PRODUCT) || defined(FORCE_INCLUDE_DISASSEMBLER) +#if defined(DART_DYNAMIC_MODULES) + if (!FLAG_support_disassembler) { + return; + } + uword start = PayloadStart(); + intptr_t size = Size(); + if (formatter == NULL) { + KernelBytecodeDisassembler::Disassemble(start, start + size, *this); + } else { + KernelBytecodeDisassembler::Disassemble(start, start + size, formatter, + *this); + } +#endif // defined(DART_DYNAMIC_MODULES) +#endif // !defined(PRODUCT) || defined(FORCE_INCLUDE_DISASSEMBLER) +} + +BytecodePtr Bytecode::New(uword instructions, + intptr_t instructions_size, + intptr_t instructions_offset, + const TypedDataBase& binary, + const ObjectPool& object_pool) { + ASSERT(Object::bytecode_class() != Class::null()); + Bytecode& result = Bytecode::Handle(); + { + auto raw = Object::Allocate(Heap::kOld); + NoSafepointScope no_safepoint; + result = raw; + result.set_instructions(instructions); + result.set_instructions_size(instructions_size); + result.set_object_pool(object_pool); + result.set_pc_descriptors(Object::empty_descriptors()); + result.set_binary(binary); + result.set_instructions_binary_offset(instructions_offset); + result.set_code_offset(0); + result.set_source_positions_binary_offset(0); + } + return result.ptr(); +} + +TokenPosition Bytecode::GetTokenIndexOfPC(uword return_address) const { +#if defined(DART_DYNAMIC_MODULES) + if (!HasSourcePositions()) { + return TokenPosition::kNoSource; + } + Zone* zone = Thread::Current()->zone(); + uword pc_offset = return_address - PayloadStart(); + // pc_offset could equal to bytecode size if the last instruction is Throw. + ASSERT(pc_offset <= static_cast(Size())); + bytecode::BytecodeSourcePositionsIterator iter(zone, *this); + TokenPosition token_pos = TokenPosition::kNoSource; + while (iter.MoveNext()) { + if (pc_offset <= iter.PcOffset()) { + break; + } + token_pos = iter.TokenPos(); + } + return token_pos; +#else + UNREACHABLE(); +#endif +} + +intptr_t Bytecode::GetTryIndexAtPc(uword return_address) const { +#if defined(DART_DYNAMIC_MODULES) + intptr_t try_index = -1; + const uword pc_offset = return_address - PayloadStart(); + const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors()); + PcDescriptors::Iterator iter(descriptors, UntaggedPcDescriptors::kAnyKind); + while (iter.MoveNext()) { + // PC descriptors for try blocks in bytecode are generated in pairs, + // marking start and end of a try block. + // See BytecodeReaderHelper::ReadExceptionsTable for details. + const intptr_t current_try_index = iter.TryIndex(); + const uword start_pc = iter.PcOffset(); + if (pc_offset < start_pc) { + break; + } + const bool has_next = iter.MoveNext(); + ASSERT(has_next); + const uword end_pc = iter.PcOffset(); + if (start_pc <= pc_offset && pc_offset < end_pc) { + ASSERT(try_index < current_try_index); + try_index = current_try_index; + } + } + return try_index; +#else + UNREACHABLE(); +#endif +} + +uword Bytecode::GetFirstDebugCheckOpcodePc() const { +#if defined(DART_DYNAMIC_MODULES) + uword pc = PayloadStart(); + const uword end_pc = pc + Size(); + while (pc < end_pc) { + if (KernelBytecode::IsDebugCheckOpcode( + reinterpret_cast(pc))) { + return pc; + } + pc = KernelBytecode::Next(pc); + } + return 0; +#else + UNREACHABLE(); +#endif +} + +uword Bytecode::GetDebugCheckedOpcodeReturnAddress(uword from_offset, + uword to_offset) const { +#if defined(DART_DYNAMIC_MODULES) + uword pc = PayloadStart() + from_offset; + const uword end_pc = pc + (to_offset - from_offset); + while (pc < end_pc) { + uword next_pc = KernelBytecode::Next(pc); + if (KernelBytecode::IsDebugCheckedOpcode( + reinterpret_cast(pc))) { + // Return the pc after the opcode, i.e. its 'return address'. + return next_pc; + } + pc = next_pc; + } + return 0; +#else + UNREACHABLE(); +#endif +} + +const char* Bytecode::ToCString() const { + return Thread::Current()->zone()->PrintToString("Bytecode(%s)", + QualifiedName()); +} + +static const char* BytecodeStubName(const Bytecode& bytecode) { + if (bytecode.ptr() == Object::implicit_getter_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_ImplicitGetter"; + } else if (bytecode.ptr() == Object::implicit_setter_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_ImplicitSetter"; + } else if (bytecode.ptr() == + Object::implicit_static_getter_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_ImplicitStaticGetter"; + } else if (bytecode.ptr() == Object::method_extractor_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_MethodExtractor"; + } else if (bytecode.ptr() == Object::invoke_closure_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_InvokeClosure"; + } else if (bytecode.ptr() == Object::invoke_field_bytecode().ptr()) { + return "[Bytecode Stub] VMInternal_InvokeField"; + } + return "[unknown stub]"; +} + +const char* Bytecode::Name() const { + Zone* zone = Thread::Current()->zone(); + const Function& fun = Function::Handle(zone, function()); + if (fun.IsNull()) { + return BytecodeStubName(*this); + } + const char* function_name = + String::Handle(zone, fun.UserVisibleName()).ToCString(); + return zone->PrintToString("[Bytecode] %s", function_name); +} + +const char* Bytecode::QualifiedName() const { + Zone* zone = Thread::Current()->zone(); + const Function& fun = Function::Handle(zone, function()); + if (fun.IsNull()) { + return BytecodeStubName(*this); + } + const char* function_name = + String::Handle(zone, fun.QualifiedScrubbedName()).ToCString(); + return zone->PrintToString("[Bytecode] %s", function_name); +} + +const char* Bytecode::FullyQualifiedName() const { + Zone* zone = Thread::Current()->zone(); + const Function& fun = Function::Handle(zone, function()); + if (fun.IsNull()) { + return BytecodeStubName(*this); + } + const char* function_name = fun.ToFullyQualifiedCString(); + return zone->PrintToString("[Bytecode] %s", function_name); +} + +void Bytecode::set_binary(const TypedDataBase& binary) const { + ASSERT(binary.IsNull() || binary.IsExternalOrExternalView()); + untag()->set_binary(binary.ptr()); +} + intptr_t Context::GetLevel() const { intptr_t level = 0; Context& parent_ctx = Context::Handle(parent()); @@ -26389,6 +26895,26 @@ const char* StackTrace::ToCString() const { } const uword pc_offset = stack_trace.PcOffsetAtFrame(i); + + // A visible frame ends any gap we might be in. + in_gap = false; + +#if defined(DART_DYNAMIC_MODULES) + if (code_object.IsBytecode()) { + const auto& bytecode = Bytecode::Cast(code_object); + function = bytecode.function(); + + if (!function.IsNull() && + (FLAG_show_invisible_frames || function.is_visible())) { + auto const pos = + bytecode.GetTokenIndexOfPC(bytecode.PayloadStart() + pc_offset); + PrintSymbolicStackFrame(zone, &buffer, function, pos, frame_index); + frame_index++; + } + continue; + } +#endif // defined(DART_DYNAMIC_MODULES) + ASSERT(code_object.IsCode()); code ^= code_object.ptr(); ASSERT(code.IsFunctionCode()); @@ -26403,9 +26929,6 @@ const char* StackTrace::ToCString() const { const bool is_future_listener = pc_offset == StackTraceUtils::kFutureListenerPcOffset; - // A visible frame ends any gap we might be in. - in_gap = false; - #if defined(DART_PRECOMPILED_RUNTIME) // When printing non-symbolic frames, we normally print call // addresses, not return addresses, by subtracting one from the PC to diff --git a/runtime/vm/object.h b/runtime/vm/object.h index 6632b749e01..22f82936abe 100644 --- a/runtime/vm/object.h +++ b/runtime/vm/object.h @@ -56,6 +56,7 @@ CLASS_LIST(DEFINE_FORWARD_DECLARATION) #undef DEFINE_FORWARD_DECLARATION class Api; class ArgumentsDescriptor; +class BitVector; class Closure; class Code; class DeoptInstr; @@ -473,6 +474,17 @@ class Object { V(ExceptionHandlers, empty_async_exception_handlers) \ V(Array, synthetic_getter_parameter_types) \ V(Array, synthetic_getter_parameter_names) \ + V(Bytecode, implicit_getter_bytecode) \ + V(Bytecode, implicit_setter_bytecode) \ + V(Bytecode, implicit_static_getter_bytecode) \ + V(Bytecode, method_extractor_bytecode) \ + V(Bytecode, invoke_closure_bytecode) \ + V(Bytecode, invoke_field_bytecode) \ + V(Bytecode, nsm_dispatcher_bytecode) \ + V(Bytecode, dynamic_invocation_forwarder_bytecode) \ + V(Bytecode, implicit_static_closure_bytecode) \ + V(Bytecode, implicit_instance_closure_bytecode) \ + V(Bytecode, implicit_constructor_closure_bytecode) \ V(Sentinel, sentinel) \ V(Sentinel, unknown_constant) \ V(Sentinel, non_constant) \ @@ -542,6 +554,7 @@ class Object { } static ClassPtr context_class() { return context_class_; } static ClassPtr context_scope_class() { return context_scope_class_; } + static ClassPtr bytecode_class() { return bytecode_class_; } static ClassPtr sentinel_class() { return sentinel_class_; } static ClassPtr api_error_class() { return api_error_class_; } static ClassPtr language_error_class() { return language_error_class_; } @@ -989,6 +1002,7 @@ class Object { static ClassPtr exception_handlers_class_; static ClassPtr context_class_; static ClassPtr context_scope_class_; + static ClassPtr bytecode_class_; static ClassPtr sentinel_class_; static ClassPtr singletargetcache_class_; static ClassPtr unlinkedcall_class_; @@ -1012,6 +1026,7 @@ class Object { friend void UntaggedObject::Validate(IsolateGroup* isolate_group) const; friend class Closure; friend class InstanceDeserializationCluster; + friend class Interpreter; friend class ObjectGraphCopier; // For Object::InitializeObject friend class Simd128MessageDeserializationCluster; friend class OneByteString; @@ -1787,6 +1802,15 @@ class Class : public Object { bool is_loaded() const { return IsLoadedBit::decode(state_bits()); } void set_is_loaded(bool value) const; +#if defined(DART_DYNAMIC_MODULES) + bool is_declared_in_bytecode() const { + return IsDeclaredInBytecodeBit::decode(state_bits()); + } + void set_is_declared_in_bytecode(bool value) const; +#else + bool is_declared_in_bytecode() const { return false; } +#endif // defined(DART_DYNAMIC_MODULES) + uint16_t num_native_fields() const { return untag()->num_native_fields_; } void set_num_native_fields(uint16_t value) const { StoreNonPointer(&untag()->num_native_fields_, value); @@ -2075,6 +2099,8 @@ class Class : public Object { kIsDynamicallyExtendableBit, // This class has a dynamically extendable subtype. kHasDynamicallyExtendableSubtypesBit, + // This class was loaded from bytecode at runtime. + kIsDeclaredInBytecodeBit, }; class ConstBit : public BitField {}; class ImplementedBit : public BitField {}; @@ -2120,6 +2146,8 @@ class Class : public Object { bool, kHasDynamicallyExtendableSubtypesBit, 1> {}; + class IsDeclaredInBytecodeBit + : public BitField {}; void set_name(const String& value) const; void set_user_name(const String& value) const; @@ -2240,6 +2268,7 @@ class Class : public Object { friend class Instance; friend class Object; friend class Type; + friend class InterpreterHelpers; friend class Intrinsifier; friend class ProgramWalker; friend class Precompiler; @@ -2920,6 +2949,7 @@ class ICData : public CallSiteData { friend class Class; friend class VMDeserializationRoots; friend class ICDataTestTask; + friend class Interpreter; friend class VMSerializationRoots; }; @@ -3231,6 +3261,16 @@ class Function : public Object { return OFFSET_OF(UntaggedFunction, unchecked_entry_point_); } +#if defined(DART_DYNAMIC_MODULES) + void AttachBytecode(const Bytecode& bytecode) const; + inline BytecodePtr GetBytecode() const; + static inline BytecodePtr GetBytecode(FunctionPtr function); + inline bool HasBytecode() const; + static inline bool HasBytecode(FunctionPtr function); +#else + inline bool HasBytecode() const { return false; } +#endif + virtual uword Hash() const; // Returns true if there is at least one debugger breakpoint @@ -3562,6 +3602,12 @@ class Function : public Object { #undef DEFINE_GETTERS_AND_SETTERS +#if defined(DART_DYNAMIC_MODULES) + bool is_declared_in_bytecode() const; +#else + bool is_declared_in_bytecode() const { return false; } +#endif // defined(DART_DYNAMIC_MODULES) + intptr_t kernel_offset() const { #if defined(DART_PRECOMPILED_RUNTIME) return 0; @@ -4042,11 +4088,19 @@ class Function : public Object { static StringPtr CreateDynamicInvocationForwarderName(const String& name); -#if !defined(DART_PRECOMPILED_RUNTIME) +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) FunctionPtr CreateDynamicInvocationForwarder( const String& mangled_name) const; FunctionPtr GetDynamicInvocationForwarder(const String& mangled_name) const; + + // Fills in [is_covariant] and [is_generic_covariant_impl] vectors + // according to covariance attributes of function parameters. + // + // [is_covariant] and [is_generic_covariant_impl] should contain bitvectors + // of function.NumParameters() length. + void ReadParameterCovariance(BitVector* is_covariant, + BitVector* is_generic_covariant_impl) const; #endif // Slow function, use in asserts to track changes in important library @@ -4507,6 +4561,12 @@ class Field : public Object { } bool is_shared() const { return SharedBit::decode(kind_bits()); } +#if defined(DART_DYNAMIC_MODULES) + bool is_declared_in_bytecode() const; +#else + bool is_declared_in_bytecode() const { return false; } +#endif // defined(DART_DYNAMIC_MODULES) + intptr_t kernel_offset() const { #if defined(DART_PRECOMPILED_RUNTIME) return 0; @@ -4819,12 +4879,16 @@ class Field : public Object { FunctionPtr InitializerFunction() const { return untag()->initializer_function(); } - void SetInitializerFunction(const Function& initializer) const; bool HasInitializerFunction() const; static intptr_t initializer_function_offset() { return OFFSET_OF(UntaggedField, initializer_function_); } +#if !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) + FunctionPtr CreateFieldInitializerFunction(Thread* thread) const; + void SetInitializerFunction(const Function& initializer) const; +#endif // !defined(DART_PRECOMPILED_RUNTIME) || defined(DART_DYNAMIC_MODULES) + // For static fields only. Constructs a closure that gets/sets the // field value. InstancePtr GetterClosure() const; @@ -4858,6 +4922,7 @@ class Field : public Object { const Object& owner, TokenPosition token_pos, TokenPosition end_token_pos); + friend class Interpreter; // Access to bit field. friend class StoreFieldInstr; // Generated code access to bit field. enum { @@ -7418,6 +7483,109 @@ class Code : public Object { friend void DumpStackFrame(intptr_t frame_index, uword pc, uword fp); }; +class Bytecode : public Object { + public: + uword instructions() const { return untag()->instructions_; } + + uword PayloadStart() const { return instructions(); } + intptr_t Size() const { return untag()->instructions_size_; } + + ObjectPoolPtr object_pool() const { return untag()->object_pool(); } + + bool ContainsInstructionAt(uword addr) const { + return UntaggedBytecode::ContainsPC(ptr(), addr); + } + + PcDescriptorsPtr pc_descriptors() const { return untag()->pc_descriptors(); } + void set_pc_descriptors(const PcDescriptors& descriptors) const { + ASSERT(descriptors.IsOld()); + untag()->set_pc_descriptors(descriptors.ptr()); + } + + void Disassemble(DisassemblyFormatter* formatter = NULL) const; + + ExceptionHandlersPtr exception_handlers() const { + return untag()->exception_handlers(); + } + void set_exception_handlers(const ExceptionHandlers& handlers) const { + ASSERT(handlers.IsOld()); + untag()->set_exception_handlers(handlers.ptr()); + } + + FunctionPtr function() const { return untag()->function(); } + + void set_function(const Function& function) const { + ASSERT(function.IsOld()); + untag()->set_function(function.ptr()); + } + + TypedDataBasePtr binary() const { return untag()->binary(); } + + static intptr_t InstanceSize() { + return RoundedAllocationSize(sizeof(UntaggedBytecode)); + } + static BytecodePtr New(uword instructions, + intptr_t instructions_size, + intptr_t instructions_offset, + const TypedDataBase& binary, + const ObjectPool& object_pool); + + TokenPosition GetTokenIndexOfPC(uword return_address) const; + intptr_t GetTryIndexAtPc(uword return_address) const; + + // Return the pc of the first 'DebugCheck' opcode of the bytecode. + // Return 0 if none is found. + uword GetFirstDebugCheckOpcodePc() const; + + // Return the pc after the first 'debug checked' opcode in the range. + // Return 0 if none is found. + uword GetDebugCheckedOpcodeReturnAddress(uword from_offset, + uword to_offset) const; + + intptr_t instructions_binary_offset() const { + return untag()->instructions_binary_offset_; + } + void set_instructions_binary_offset(intptr_t value) const { + StoreNonPointer(&untag()->instructions_binary_offset_, value); + } + + intptr_t code_offset() const { return untag()->code_offset_; } + void set_code_offset(intptr_t value) const { + StoreNonPointer(&untag()->code_offset_, value); + } + + intptr_t source_positions_binary_offset() const { + return untag()->source_positions_binary_offset_; + } + void set_source_positions_binary_offset(intptr_t value) const { + StoreNonPointer(&untag()->source_positions_binary_offset_, value); + } + bool HasSourcePositions() const { + return (source_positions_binary_offset() != 0); + } + + const char* Name() const; + const char* QualifiedName() const; + const char* FullyQualifiedName() const; + + private: + void set_instructions(uword instructions) const { + StoreNonPointer(&untag()->instructions_, instructions); + } + void set_instructions_size(intptr_t size) const { + StoreNonPointer(&untag()->instructions_size_, size); + } + void set_object_pool(const ObjectPool& object_pool) const { + untag()->set_object_pool(object_pool.ptr()); + } + void set_binary(const TypedDataBase& binary) const; + + FINAL_HEAP_OBJECT_IMPLEMENTATION(Bytecode, Object); + friend class BytecodeDeserializationCluster; + friend class Class; + friend class SnapshotWriter; +}; + class Context : public Object { public: ContextPtr parent() const { return untag()->parent(); } @@ -8455,6 +8623,7 @@ class Instance : public Object { friend class TypedDataView; friend class InstanceSerializationCluster; friend class InstanceDeserializationCluster; + friend class Interpreter; friend class ClassDeserializationCluster; // vtable friend class InstanceMorpher; friend class Obfuscator; // RawGetFieldAtOffset, RawSetFieldAtOffset @@ -11044,6 +11213,7 @@ class Array : public Instance { FINAL_HEAP_OBJECT_IMPLEMENTATION(Array, Instance); friend class Class; friend class ImmutableArray; + friend class Interpreter; friend class Object; friend class String; friend class MessageDeserializer; @@ -13255,6 +13425,24 @@ void Object::setPtr(ObjectPtr value, intptr_t default_cid) { set_vtable(builtin_vtables_[cid]); } +#if defined(DART_DYNAMIC_MODULES) +BytecodePtr Function::GetBytecode() const { + return GetBytecode(ptr()); +} + +BytecodePtr Function::GetBytecode(FunctionPtr function) { + return Bytecode::RawCast(function.untag()->ic_data_array_or_bytecode()); +} + +bool Function::HasBytecode() const { + return HasBytecode(ptr()); +} + +bool Function::HasBytecode(FunctionPtr function) { + return function.untag()->ic_data_array_or_bytecode()->IsBytecode(); +} +#endif // defined(DART_DYNAMIC_MODULES) + intptr_t Field::HostOffset() const { ASSERT(is_instance()); // Valid only for dart instance fields. return (Smi::Value(untag()->host_offset_or_field_id()) * kCompressedWordSize); diff --git a/runtime/vm/object_graph_copy.cc b/runtime/vm/object_graph_copy.cc index 87f7cfb8b88..2587a49add7 100644 --- a/runtime/vm/object_graph_copy.cc +++ b/runtime/vm/object_graph_copy.cc @@ -33,6 +33,7 @@ V(CodeSourceMap) \ V(CompressedStackMaps) \ V(ContextScope) \ + V(Bytecode) \ V(DynamicLibrary) \ V(Error) \ V(ExceptionHandlers) \ diff --git a/runtime/vm/object_service.cc b/runtime/vm/object_service.cc index 4dd1e141f84..836dd0c9fb5 100644 --- a/runtime/vm/object_service.cc +++ b/runtime/vm/object_service.cc @@ -1084,6 +1084,54 @@ void Code::PrintJSONImpl(JSONStream* stream, bool ref) const { void Code::PrintImplementationFieldsImpl(const JSONArray& jsarr_fields) const {} +void Bytecode::PrintJSONImpl(JSONStream* stream, bool ref) const { + // N.B. This is polymorphic with Code. + + JSONObject jsobj(stream); + AddCommonObjectProperties(&jsobj, "Code", ref); + int64_t compile_timestamp = 0; + jsobj.AddFixedServiceId("code/%" Px64 "-%" Px "", compile_timestamp, + PayloadStart()); + const char* qualified_name = QualifiedName(); + const char* vm_name = Name(); + AddNameProperties(&jsobj, qualified_name, vm_name); + + jsobj.AddProperty("kind", "Dart"); + jsobj.AddProperty("_optimized", false); + jsobj.AddProperty("_intrinsic", false); + jsobj.AddProperty("_native", false); + if (ref) { + return; + } + const Function& fun = Function::Handle(function()); + jsobj.AddProperty("function", fun); + jsobj.AddPropertyF("_startAddress", "%" Px "", PayloadStart()); + jsobj.AddPropertyF("_endAddress", "%" Px "", PayloadStart() + Size()); + jsobj.AddProperty("_alive", true); + const ObjectPool& obj_pool = ObjectPool::Handle(object_pool()); + jsobj.AddProperty("_objectPool", obj_pool); + { + JSONArray jsarr(&jsobj, "_disassembly"); + DisassembleToJSONStream formatter(jsarr); + Disassemble(&formatter); + } + const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors()); + if (!descriptors.IsNull()) { + JSONObject desc(&jsobj, "_descriptors"); + descriptors.PrintToJSONObject(&desc, false); + } + + { + JSONArray inlined_functions(&jsobj, "_inlinedFunctions"); + } + { + JSONArray inline_intervals(&jsobj, "_inlinedIntervals"); + } +} + +void Bytecode::PrintImplementationFieldsImpl( + const JSONArray& jsarr_fields) const {} + void Context::PrintJSONImpl(JSONStream* stream, bool ref) const { JSONObject jsobj(stream); // TODO(turnidge): Should the user level type for Context be Context diff --git a/runtime/vm/raw_object.cc b/runtime/vm/raw_object.cc index ef26b0e76f9..18b731242f2 100644 --- a/runtime/vm/raw_object.cc +++ b/runtime/vm/raw_object.cc @@ -525,6 +525,7 @@ COMPRESSED_VISITOR(TypeParameter) COMPRESSED_VISITOR(Function) COMPRESSED_VISITOR(Closure) COMPRESSED_VISITOR(LibraryPrefix) +COMPRESSED_VISITOR(Bytecode) REGULAR_VISITOR(SingleTargetCache) REGULAR_VISITOR(UnlinkedCall) NULL_VISITOR(MonomorphicSmiableCall) @@ -681,6 +682,16 @@ intptr_t UntaggedCode::VisitCodePointers(CodePtr raw_obj, #endif } +bool UntaggedBytecode::ContainsPC(ObjectPtr raw_obj, uword pc) { + if (raw_obj->IsBytecode()) { + BytecodePtr raw_bytecode = static_cast(raw_obj); + uword start = raw_bytecode->untag()->instructions_; + uword size = raw_bytecode->untag()->instructions_size_; + return (pc - start) <= size; // pc may point past last instruction. + } + return false; +} + intptr_t UntaggedObjectPool::VisitObjectPoolPointers( ObjectPoolPtr raw_obj, ObjectPointerVisitor* visitor) { diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h index 537ebca106a..97729fb624f 100644 --- a/runtime/vm/raw_object.h +++ b/runtime/vm/raw_object.h @@ -836,6 +836,8 @@ class UntaggedObject { friend class Instance; // StorePointer friend class StackFrame; // GetCodeObject assertion. friend class CodeLookupTableBuilder; // profiler + friend class Interpreter; + friend class InterpreterHelpers; friend class ObjectLocator; friend class WriteBarrierUpdateVisitor; // CheckHeapPointerStore friend class OffsetsTable; @@ -1179,6 +1181,8 @@ class UntaggedClass : public UntaggedObject { #endif // !defined(DART_PRECOMPILED_RUNTIME) friend class Instance; + friend class Interpreter; + friend class InterpreterHelpers; friend class IsolateGroup; friend class Object; friend class UntaggedInstance; @@ -1387,6 +1391,8 @@ class UntaggedFunction : public UntaggedObject { private: friend class Class; + friend class Interpreter; + friend class InterpreterHelpers; friend class UnitDeserializationRoots; RAW_HEAP_OBJECT_IMPLEMENTATION(Function); @@ -1416,8 +1422,8 @@ class UntaggedFunction : public UntaggedObject { UNREACHABLE(); return nullptr; } - // ICData of unoptimized code. - COMPRESSED_POINTER_FIELD(ArrayPtr, ic_data_array); + // ICData of unoptimized code or Bytecode. + COMPRESSED_POINTER_FIELD(ObjectPtr, ic_data_array_or_bytecode); // Currently active code. Accessed from generated code. COMPRESSED_POINTER_FIELD(CodePtr, code); #if defined(DART_PRECOMPILED_RUNTIME) @@ -1607,6 +1613,8 @@ class UntaggedField : public UntaggedObject { #endif // !defined(DART_PRECOMPILED_RUNTIME) friend class CidRewriteVisitor; + friend class Interpreter; + friend class InterpreterHelpers; friend class GuardFieldClassInstr; // For sizeof(guarded_cid_/...) friend class LoadFieldInstr; // For sizeof(guarded_cid_/...) friend class StoreFieldInstr; // For sizeof(guarded_cid_/...) @@ -1964,6 +1972,36 @@ class UntaggedCode : public UntaggedObject { friend class CallSiteResetter; }; +class UntaggedBytecode : public UntaggedObject { + RAW_HEAP_OBJECT_IMPLEMENTATION(Bytecode); + + uword instructions_; + intptr_t instructions_size_; + + COMPRESSED_POINTER_FIELD(ObjectPoolPtr, object_pool); + VISIT_FROM(object_pool); + COMPRESSED_POINTER_FIELD(FunctionPtr, function); + COMPRESSED_POINTER_FIELD(ArrayPtr, closures); + COMPRESSED_POINTER_FIELD(TypedDataBasePtr, binary); + COMPRESSED_POINTER_FIELD(ExceptionHandlersPtr, exception_handlers); + COMPRESSED_POINTER_FIELD(PcDescriptorsPtr, pc_descriptors); + VISIT_TO(pc_descriptors); + + ObjectPtr* to_snapshot(Snapshot::Kind kind) { + return reinterpret_cast(&pc_descriptors_); + } + + int32_t instructions_binary_offset_; + int32_t code_offset_; + int32_t source_positions_binary_offset_; + + static bool ContainsPC(ObjectPtr raw_obj, uword pc); + + friend class Function; + friend class Interpreter; + friend class StackFrame; +}; + class UntaggedObjectPool : public UntaggedObject { RAW_HEAP_OBJECT_IMPLEMENTATION(ObjectPool); @@ -1988,6 +2026,7 @@ class UntaggedObjectPool : public UntaggedObject { friend class Object; friend class CodeSerializationCluster; + friend class Interpreter; friend class UnitSerializationRoots; friend class UnitDeserializationRoots; }; @@ -2016,6 +2055,7 @@ class UntaggedInstructions : public UntaggedObject { friend class Function; friend class ImageReader; friend class ImageWriter; + friend class Interpreter; friend class AssemblyImageWriter; friend class BlobImageWriter; }; @@ -2434,6 +2474,7 @@ class UntaggedContext : public UntaggedObject { COMPRESSED_VARIABLE_POINTER_FIELDS(ObjectPtr, element, data) friend class Object; + friend class Interpreter; friend void UpdateLengthField(intptr_t, ObjectPtr, ObjectPtr); // num_variables_ @@ -2613,6 +2654,8 @@ class UntaggedSubtypeTestCache : public UntaggedObject { VISIT_TO(cache) uint32_t num_inputs_; uint32_t num_occupied_; + + friend class Interpreter; }; class UntaggedLoadingUnit : public UntaggedObject { @@ -2741,6 +2784,7 @@ class UntaggedTypeArguments : public UntaggedInstance { COMPRESSED_VARIABLE_POINTER_FIELDS(AbstractTypePtr, element, types) friend class Object; + friend class Interpreter; }; class UntaggedTypeParameters : public UntaggedObject { @@ -2797,6 +2841,7 @@ class UntaggedAbstractType : public UntaggedInstance { private: RAW_HEAP_OBJECT_IMPLEMENTATION(AbstractType); + friend class Interpreter; friend class ObjectStore; friend class StubCode; }; @@ -2961,6 +3006,7 @@ class UntaggedClosure : public UntaggedInstance { CompressedObjectPtr* to_snapshot(Snapshot::Kind kind) { return to(); } + friend class Interpreter; friend class UnitDeserializationRoots; }; @@ -2985,6 +3031,7 @@ class UntaggedMint : public UntaggedInteger { friend class Api; friend class Class; friend class Integer; + friend class Interpreter; }; COMPILE_ASSERT(sizeof(UntaggedMint) == 16); @@ -2996,6 +3043,7 @@ class UntaggedDouble : public UntaggedNumber { friend class Api; friend class Class; + friend class Interpreter; }; COMPILE_ASSERT(sizeof(UntaggedDouble) == 16); @@ -3234,6 +3282,7 @@ class UntaggedArray : public UntaggedInstance { friend class CodeSerializationCluster; friend class CodeDeserializationCluster; friend class Deserializer; + friend class Interpreter; friend class UntaggedCode; friend class UntaggedImmutableArray; friend class GrowableObjectArray; @@ -3315,6 +3364,7 @@ class UntaggedFloat32x4 : public UntaggedInstance { ALIGN8 float value_[4]; friend class Class; + friend class Interpreter; public: float x() const { return value_[0]; } @@ -3350,6 +3400,7 @@ class UntaggedFloat64x2 : public UntaggedInstance { ALIGN8 double value_[2]; friend class Class; + friend class Interpreter; public: double x() const { return value_[0]; } diff --git a/runtime/vm/raw_object_fields.cc b/runtime/vm/raw_object_fields.cc index e5cbd571a14..e77f2c1a1df 100644 --- a/runtime/vm/raw_object_fields.cc +++ b/runtime/vm/raw_object_fields.cc @@ -34,7 +34,7 @@ namespace dart { F(Function, owner_) \ F(Function, signature_) \ F(Function, data_) \ - F(Function, ic_data_array_) \ + F(Function, ic_data_array_or_bytecode_) \ F(Function, code_) \ F(ClosureData, context_scope_) \ F(ClosureData, parent_function_) \ @@ -91,6 +91,12 @@ namespace dart { F(Code, compressed_stackmaps_) \ F(Code, inlined_id_to_function_) \ F(Code, code_source_map_) \ + F(Bytecode, object_pool_) \ + F(Bytecode, instructions_) \ + F(Bytecode, function_) \ + F(Bytecode, exception_handlers_) \ + F(Bytecode, pc_descriptors_) \ + F(Bytecode, closures_) \ F(ExceptionHandlers, handled_types_data_) \ F(Context, parent_) \ F(SingleTargetCache, target_) \ diff --git a/runtime/vm/reusable_handles.h b/runtime/vm/reusable_handles.h index 80937cc45bc..066581440a8 100644 --- a/runtime/vm/reusable_handles.h +++ b/runtime/vm/reusable_handles.h @@ -83,6 +83,8 @@ REUSABLE_HANDLE_LIST(REUSABLE_SCOPE) ReusableClassHandleScope reused_class_handle(thread); #define REUSABLE_CODE_HANDLESCOPE(thread) \ ReusableCodeHandleScope reused_code_handle(thread); +#define REUSABLE_BYTECODE_HANDLESCOPE(thread) \ + ReusableBytecodeHandleScope reused_bytecode_handle(thread); #define REUSABLE_ERROR_HANDLESCOPE(thread) \ ReusableErrorHandleScope reused_error_handle(thread); #define REUSABLE_EXCEPTION_HANDLERS_HANDLESCOPE(thread) \ diff --git a/runtime/vm/runtime_entry.cc b/runtime/vm/runtime_entry.cc index d9950428fdd..5d3c98e5382 100644 --- a/runtime/vm/runtime_entry.cc +++ b/runtime/vm/runtime_entry.cc @@ -23,6 +23,7 @@ #include "vm/flags.h" #include "vm/heap/verifier.h" #include "vm/instructions.h" +#include "vm/interpreter.h" #include "vm/kernel_isolate.h" #include "vm/message.h" #include "vm/message_handler.h" @@ -237,6 +238,7 @@ static void DoThrowNullError(Isolate* isolate, StackFrameIterator::kNoCrossThreadIteration); const StackFrame* caller_frame = iterator.NextFrame(); ASSERT(caller_frame->IsDartFrame()); + ASSERT(!caller_frame->is_interpreted()); const Code& code = Code::Handle(zone, caller_frame->LookupDartCode()); const uword pc_offset = caller_frame->pc() - code.PayloadStart(); @@ -857,6 +859,129 @@ DEFINE_RUNTIME_ENTRY(CloneSuspendState, 1) { RuntimeAllocationEpilogue(thread); } +// Invoke field getter before dispatch. +// Arg0: instance. +// Arg1: field name (may be demangled during call). +// Return value: field value. +DEFINE_RUNTIME_ENTRY(GetFieldForDispatch, 2) { +#if defined(DART_DYNAMIC_MODULES) + const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0)); + String& name = String::CheckedHandle(zone, arguments.ArgAt(1)); + const Class& receiver_class = Class::Handle(zone, receiver.clazz()); + if (Function::IsDynamicInvocationForwarderName(name)) { + name = Function::DemangleDynamicInvocationForwarderName(name); + arguments.SetArgAt(1, name); // Reflect change in arguments. + } + const String& getter_name = String::Handle(zone, Field::GetterName(name)); + const int kTypeArgsLen = 0; + const int kNumArguments = 1; + ArgumentsDescriptor args_desc(Array::Handle( + zone, ArgumentsDescriptor::NewBoxed(kTypeArgsLen, kNumArguments))); + const Function& getter = Function::Handle( + zone, Resolver::ResolveDynamicForReceiverClass( + receiver_class, getter_name, args_desc, /*allow_add=*/true)); + ASSERT(!getter.IsNull()); // An InvokeFieldDispatcher function was created. + const Array& args = Array::Handle(zone, Array::New(kNumArguments)); + args.SetAt(0, receiver); + const Object& result = + Object::Handle(zone, DartEntry::InvokeFunction(getter, args)); + ThrowIfError(result); + arguments.SetReturn(result); +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + +// Converts arguments descriptor passed to an implicit closure +// into an arguments descriptor for the target function. +// Arg0: implicit closure arguments descriptor +// Arg1: target function +// Return value: target arguments descriptor +DEFINE_RUNTIME_ENTRY(AdjustArgumentsDesciptorForImplicitClosure, 2) { +#if defined(DART_DYNAMIC_MODULES) + const auto& descriptor = Array::CheckedHandle(zone, arguments.ArgAt(0)); + const auto& target = Function::CheckedHandle(zone, arguments.ArgAt(1)); + + const ArgumentsDescriptor args_desc(descriptor); + intptr_t type_args_len = args_desc.TypeArgsLen(); + intptr_t num_arguments = args_desc.Count(); + + if (target.is_static()) { + if (target.IsFactory()) { + // Factory always takes type arguments via a positional parameter. + type_args_len = 0; + } else { + // Drop closure receiver. + --num_arguments; + } + } else { + if (target.IsGenerativeConstructor()) { + // Type arguments are not passed to a generative constructor. + type_args_len = 0; + } else { + // No need to adjust arguments descriptor. + arguments.SetReturn(descriptor); + return; + } + } + + const auto& optional_arguments_names = + Array::Handle(zone, args_desc.GetArgumentNames()); + const auto& result = Array::Handle( + zone, ArgumentsDescriptor::NewBoxed(type_args_len, num_arguments, + optional_arguments_names)); + arguments.SetReturn(result); +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + +// Check that arguments are valid for the given closure. +// Arg0: closure +// Arg1: arguments descriptor +// Return value: whether the arguments are valid +DEFINE_RUNTIME_ENTRY(ClosureArgumentsValid, 2) { +#if defined(DART_DYNAMIC_MODULES) + const auto& closure = Closure::CheckedHandle(zone, arguments.ArgAt(0)); + const auto& descriptor = Array::CheckedHandle(zone, arguments.ArgAt(1)); + + const auto& function = Function::Handle(zone, closure.function()); + const ArgumentsDescriptor args_desc(descriptor); + if (!function.AreValidArguments(args_desc, nullptr)) { + arguments.SetReturn(Bool::False()); + } else if (!closure.IsGeneric() && args_desc.TypeArgsLen() > 0) { + // The arguments may be valid for the closure function itself, but if the + // closure has delayed type arguments, no type arguments should be provided. + arguments.SetReturn(Bool::False()); + } else { + arguments.SetReturn(Bool::True()); + } +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + +// Resolve 'call' function of receiver. +// Arg0: receiver (not a closure). +// Arg1: arguments descriptor +// Return value: 'call' function'. +DEFINE_RUNTIME_ENTRY(ResolveCallFunction, 2) { +#if defined(DART_DYNAMIC_MODULES) + const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0)); + const Array& descriptor = Array::CheckedHandle(zone, arguments.ArgAt(1)); + ArgumentsDescriptor args_desc(descriptor); + ASSERT(!receiver.IsClosure()); // Interpreter tests for closure. + Class& cls = Class::Handle(zone, receiver.clazz()); + Function& call_function = Function::Handle( + zone, + Resolver::ResolveDynamicForReceiverClass(cls, Symbols::call(), args_desc, + /*allow_add=*/false)); + arguments.SetReturn(call_function); +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + // Helper routine for tracing a type check. static void PrintTypeCheck(const char* message, const Instance& instance, @@ -1257,6 +1382,7 @@ DEFINE_RUNTIME_ENTRY(TypeCheck, 7) { DartFrameIterator iterator(thread, StackFrameIterator::kNoCrossThreadIteration); StackFrame* caller_frame = iterator.NextFrame(); + ASSERT(!caller_frame->is_interpreted()); const auto& dispatcher = Function::Handle(zone, caller_frame->LookupDartFunction()); ASSERT(dispatcher.IsInvokeFieldDispatcher()); @@ -1388,6 +1514,7 @@ DEFINE_RUNTIME_ENTRY(TypeCheck, 7) { DartFrameIterator iterator(thread, StackFrameIterator::kNoCrossThreadIteration); StackFrame* caller_frame = iterator.NextFrame(); + ASSERT(!caller_frame->is_interpreted()); const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode()); const ObjectPool& pool = @@ -1490,6 +1617,7 @@ DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) { StackFrameIterator::kNoCrossThreadIteration); StackFrame* caller_frame = iterator.NextFrame(); ASSERT(caller_frame != nullptr); + ASSERT(!caller_frame->is_interpreted()); const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode()); ASSERT(!caller_code.IsNull()); ASSERT(caller_code.is_optimized()); @@ -1536,8 +1664,10 @@ DEFINE_RUNTIME_ENTRY(BreakpointRuntimeHandler, 0) { StackFrame* caller_frame = iterator.NextFrame(); ASSERT(caller_frame != nullptr); Code& orig_stub = Code::Handle(zone); - orig_stub = - isolate->group()->debugger()->GetPatchedStubAddress(caller_frame->pc()); + if (!caller_frame->is_interpreted()) { + orig_stub = + isolate->group()->debugger()->GetPatchedStubAddress(caller_frame->pc()); + } const Error& error = Error::Handle(zone, isolate->debugger()->PauseBreakpoint()); ThrowIfError(error); @@ -1659,6 +1789,7 @@ static void TrySwitchInstanceCall(Thread* thread, #endif // Monomorphic/megamorphic calls are only for unoptimized code. + if (caller_frame->is_interpreted()) return; ASSERT(!caller_code.is_optimized()); // Code is detached from its function. This will prevent us from resetting @@ -2742,6 +2873,44 @@ DEFINE_RUNTIME_ENTRY(SwitchableCallMiss, 2) { handler.ResolveSwitchAndReturn(old_data); } +// Handles interpreted interface call cache miss. +// Arg0: receiver +// Arg1: target name +// Arg2: arguments descriptor +// Returns: target function (can only be null in AOT runtime) +// Modifies the instance call table in current interpreter. +DEFINE_RUNTIME_ENTRY(InterpretedInstanceCallMissHandler, 3) { +#if defined(DART_DYNAMIC_MODULES) + const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0)); + const String& target_name = String::CheckedHandle(zone, arguments.ArgAt(1)); + const Array& arg_desc = Array::CheckedHandle(zone, arguments.ArgAt(2)); + + ArgumentsDescriptor arguments_descriptor(arg_desc); + const Class& receiver_class = Class::Handle(zone, receiver.clazz()); + Function& target_function = Function::Handle(zone); + if (receiver_class.EnsureIsFinalized(thread) == Error::null()) { + const Class& cls = Class::Handle(zone, receiver.clazz()); + const bool allow_add = !FLAG_precompiled_mode; + target_function = Resolver::ResolveDynamicForReceiverClass( + cls, target_name, arguments_descriptor, allow_add); + } + + // TODO(regis): In order to substitute 'simple_instance_of_function', the 2nd + // arg to the call, the type, is needed. + + if (target_function.IsNull()) { + target_function = + InlineCacheMissHelper(receiver_class, arg_desc, target_name); + } +#if !defined(DART_PRECOMPILED_RUNTIME) + ASSERT(!target_function.IsNull()); +#endif + arguments.SetReturn(target_function); +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + #if defined(DART_PRECOMPILED_RUNTIME) // Used to find the correct receiver and function to invoke or to fall back to // invoking noSuchMethod when lazy dispatchers are disabled. Returns the @@ -2951,6 +3120,40 @@ DEFINE_RUNTIME_ENTRY(NoSuchMethodFromPrologue, 4) { arguments.SetReturn(result); } +// Invoke appropriate noSuchMethod function (or in the case of no lazy +// dispatchers, walk the receiver to find the correct method to call). +// Arg0: receiver +// Arg1: function name. +// Arg2: arguments descriptor array. +// Arg3: arguments array. +DEFINE_RUNTIME_ENTRY(InvokeNoSuchMethod, 4) { +#if defined(DART_DYNAMIC_MODULES) + const Instance& receiver = Instance::CheckedHandle(zone, arguments.ArgAt(0)); + const String& original_function_name = + String::CheckedHandle(zone, arguments.ArgAt(1)); + const Array& orig_arguments_desc = + Array::CheckedHandle(zone, arguments.ArgAt(2)); + const Array& orig_arguments = Array::CheckedHandle(zone, arguments.ArgAt(3)); + + auto& result = Object::Handle(zone); +#if defined(DART_PRECOMPILED_RUNTIME) + // Failing to find the method could be due to the lack of lazy invoke field + // dispatchers, so attempt a deeper search before calling noSuchMethod. + result = InvokeCallThroughGetterOrNoSuchMethod( + thread, zone, receiver, original_function_name, orig_arguments, + orig_arguments_desc); +#else + result = + DartEntry::InvokeNoSuchMethod(thread, receiver, original_function_name, + orig_arguments, orig_arguments_desc); +#endif + ThrowIfError(result); + arguments.SetReturn(result); +#else + UNREACHABLE(); +#endif // defined(DART_DYNAMIC_MODULES) +} + #if !defined(PRODUCT) && !defined(DART_PRECOMPILED_RUNTIME) // The following code is used to stress test // - deoptimization @@ -3000,9 +3203,13 @@ static void HandleStackOverflowTestCases(Thread* thread) { ASSERT(frame != nullptr); Code& code = Code::Handle(); Function& function = Function::Handle(); - code = frame->LookupDartCode(); - ASSERT(!code.IsNull()); - function = code.function(); + if (frame->is_interpreted()) { + function = frame->LookupDartFunction(); + } else { + code = frame->LookupDartCode(); + ASSERT(!code.IsNull()); + function = code.function(); + } ASSERT(!function.IsNull()); const char* function_name = nullptr; if ((FLAG_deoptimize_filter != nullptr) || @@ -3152,15 +3359,32 @@ DEFINE_RUNTIME_ENTRY(InterruptOrStackOverflow, 0) { // persist. uword stack_overflow_flags = thread->GetAndClearStackOverflowFlags(); + bool interpreter_stack_overflow = false; +#if defined(DART_DYNAMIC_MODULES) + Interpreter* interpreter = thread->interpreter(); + if (interpreter != nullptr) { + interpreter_stack_overflow = + interpreter->get_sp() >= interpreter->overflow_stack_limit(); + } +#endif // defined(DART_DYNAMIC_MODULES) + // If an interrupt happens at the same time as a stack overflow, we // process the stack overflow now and leave the interrupt for next // time. - if (!thread->os_thread()->HasStackHeadroom() || + if (interpreter_stack_overflow || !thread->os_thread()->HasStackHeadroom() || IsCalleeFrameOf(thread->saved_stack_limit(), stack_pos)) { if (FLAG_verbose_stack_overflow) { OS::PrintErr("Stack overflow\n"); OS::PrintErr(" Native SP = %" Px ", stack limit = %" Px "\n", stack_pos, thread->saved_stack_limit()); +#if defined(DART_DYNAMIC_MODULES) + if (thread->interpreter() != nullptr) { + OS::PrintErr(" Interpreter SP = %" Px ", stack limit = %" Px "\n", + thread->interpreter()->get_sp(), + thread->interpreter()->overflow_stack_limit()); + } +#endif // defined(DART_DYNAMIC_MODULES) + OS::PrintErr("Call stack:\n"); OS::PrintErr("size | frame\n"); StackFrameIterator frames(ValidationPolicy::kDontValidateFrames, thread, @@ -3441,6 +3665,7 @@ void DeoptimizeAt(Thread* mutator_thread, // N.B.: Update the pending deopt table before updating the frame. The // profiler may attempt a stack walk in between. + ASSERT(!frame->is_interpreted()); mutator_thread->pending_deopts().AddPendingDeopt(frame->fp(), deopt_pc); frame->MarkForLazyDeopt(); @@ -3474,10 +3699,12 @@ void DeoptimizeFunctionsOnStack() { mutator_thread, StackFrameIterator::kAllowCrossThreadIteration); StackFrame* frame = iterator.NextFrame(); while (frame != nullptr) { - optimized_code = frame->LookupDartCode(); - if (optimized_code.is_optimized() && - !optimized_code.is_force_optimized()) { - DeoptimizeAt(mutator_thread, optimized_code, frame); + if (!frame->is_interpreted()) { + optimized_code = frame->LookupDartCode(); + if (optimized_code.is_optimized() && + !optimized_code.is_force_optimized()) { + DeoptimizeAt(mutator_thread, optimized_code, frame); + } } frame = iterator.NextFrame(); } @@ -3501,7 +3728,7 @@ static void DeoptimizeLastDartFrameIfOptimized() { DartFrameIterator iterator(mutator_thread, StackFrameIterator::kNoCrossThreadIteration); StackFrame* frame = iterator.NextFrame(); - if (frame != nullptr) { + if (frame != nullptr && !frame->is_interpreted()) { const auto& optimized_code = Code::Handle(frame->LookupDartCode()); if (optimized_code.is_optimized() && !optimized_code.is_force_optimized()) { @@ -3962,6 +4189,66 @@ DEFINE_RAW_LEAF_RUNTIME_ENTRY(MemoryMove, /*is_float=*/false, static_cast(memmove)); +#if defined(DART_DYNAMIC_MODULES) +// Interpret a function call. Should be called only for non-jitted functions. +// argc indicates the number of arguments, including the type arguments. +// argv points to the first argument. +// If argc < 0, arguments are passed at decreasing memory addresses from argv. +extern "C" uword /*ObjectPtr*/ InterpretCall(uword /*FunctionPtr*/ function_in, + uword /*ArrayPtr*/ argdesc_in, + intptr_t argc, + ObjectPtr* argv, + Thread* thread) { + FunctionPtr function = static_cast(function_in); + ArrayPtr argdesc = static_cast(argdesc_in); + Interpreter* interpreter = Interpreter::Current(); +#if defined(DEBUG) + uword exit_fp = thread->top_exit_frame_info(); + ASSERT(exit_fp != 0); + ASSERT(thread == Thread::Current()); + // Caller is InterpretCall stub called from generated code. + // We stay in "in generated code" execution state when interpreting code. + ASSERT(thread->execution_state() == Thread::kThreadInGenerated); + ASSERT(Function::HasBytecode(function)); + ASSERT(interpreter != nullptr); +#endif + // Tell MemorySanitizer 'argv' is initialized by generated code. + if (argc < 0) { + MSAN_UNPOISON(argv - argc, -argc * sizeof(ObjectPtr)); + } else { + MSAN_UNPOISON(argv, argc * sizeof(ObjectPtr)); + } + ObjectPtr result = + interpreter->Call(function, argdesc, argc, argv, Array::null(), thread); + DEBUG_ASSERT(thread->top_exit_frame_info() == exit_fp); + if (IsErrorClassId(result->GetClassIdMayBeSmi())) { + // Must not leak handles in the caller's zone. + HANDLESCOPE(thread); + // Protect the result in a handle before transitioning, which may trigger + // GC. + const Error& error = Error::Handle(Error::RawCast(result)); + // Propagating an error may cause allocation. Check if we need to block for + // a safepoint by switching to "in VM" execution state. + TransitionGeneratedToVM transition(thread); + Exceptions::PropagateError(error); + } + return static_cast(result); +} +#endif // defined(DART_DYNAMIC_MODULES) + +uword RuntimeEntry::InterpretCallEntry() { +#if defined(DART_DYNAMIC_MODULES) + uword entry = reinterpret_cast(InterpretCall); +#if defined(USING_SIMULATOR) + entry = Simulator::RedirectExternalReference(entry, + Simulator::kLeafRuntimeCall, 5); +#endif + return entry; +#else + return 0; +#endif // defined(DART_DYNAMIC_MODULES) +} + extern "C" void DFLRT_EnterSafepoint(NativeArguments __unusable_) { CHECK_STACK_ALIGNMENT; TRACE_RUNTIME_CALL("%s", "EnterSafepoint"); diff --git a/runtime/vm/runtime_entry.h b/runtime/vm/runtime_entry.h index 69ed0971bf0..e6e678fecfe 100644 --- a/runtime/vm/runtime_entry.h +++ b/runtime/vm/runtime_entry.h @@ -56,6 +56,8 @@ class RuntimeEntry : public BaseRuntimeEntry { bool can_lazy_deopt() const { return can_lazy_deopt_; } uword GetEntryPoint() const; + static uword InterpretCallEntry(); + private: const char* const name_; const void* const function_; diff --git a/runtime/vm/runtime_entry_list.h b/runtime/vm/runtime_entry_list.h index 55e8b29eb3b..1c90a6fa0b2 100644 --- a/runtime/vm/runtime_entry_list.h +++ b/runtime/vm/runtime_entry_list.h @@ -72,7 +72,13 @@ namespace dart { V(ResumeFrame) \ V(SwitchableCallMiss) \ V(NotLoaded) \ - V(FfiAsyncCallbackSend) + V(FfiAsyncCallbackSend) \ + V(GetFieldForDispatch) \ + V(AdjustArgumentsDesciptorForImplicitClosure) \ + V(ClosureArgumentsValid) \ + V(ResolveCallFunction) \ + V(InterpretedInstanceCallMissHandler) \ + V(InvokeNoSuchMethod) // Note: Leaf runtime function have C linkage, so they cannot pass C++ struct // values like ObjectPtr. diff --git a/runtime/vm/stack_frame.cc b/runtime/vm/stack_frame.cc index 1b253060076..7d32df72d5d 100644 --- a/runtime/vm/stack_frame.cc +++ b/runtime/vm/stack_frame.cc @@ -148,6 +148,10 @@ bool StackFrame::IsBareInstructionsStubFrame() const { } bool StackFrame::IsStubFrame() const { + if (is_interpreted()) { + return false; + } + if (FLAG_precompiled_mode) { return IsBareInstructionsStubFrame(); } @@ -169,6 +173,15 @@ bool StackFrame::IsStubFrame() const { const char* StackFrame::ToCString() const { ASSERT(thread_ == Thread::Current()); Zone* zone = Thread::Current()->zone(); +#if defined(DART_DYNAMIC_MODULES) + if (is_interpreted()) { + const Bytecode& bytecode = Bytecode::Handle(zone, LookupDartBytecode()); + const char* name = bytecode.IsNull() ? "Cannot find bytecode object" + : bytecode.FullyQualifiedName(); + return zone->PrintToString(" pc 0x%" Pp " fp 0x%" Pp " sp 0x%" Pp " %s", + pc(), fp(), sp(), name); + } +#endif // defined(DART_DYNAMIC_MODULES) const Code& code = Code::Handle(zone, GetCodeObject()); const char* name = code.IsNull() @@ -180,11 +193,16 @@ const char* StackFrame::ToCString() const { void ExitFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { ASSERT(visitor != nullptr); - // Visit pc marker and saved pool pointer. - ObjectPtr* last_fixed = reinterpret_cast(fp()) + - runtime_frame_layout.first_object_from_fp; - ObjectPtr* first_fixed = reinterpret_cast(fp()) + - runtime_frame_layout.last_fixed_object_from_fp; + // Visit pc marker and saved pool pointer, or, for interpreted frame, code + // object and function object. + ObjectPtr* last_fixed = + reinterpret_cast(fp()) + + (is_interpreted() ? kKBCLastFixedObjectSlotFromFp + : runtime_frame_layout.first_object_from_fp); + ObjectPtr* first_fixed = + reinterpret_cast(fp()) + + (is_interpreted() ? kKBCFirstObjectSlotFromFp + : runtime_frame_layout.last_fixed_object_from_fp); if (first_fixed <= last_fixed) { visitor->VisitPointers(first_fixed, last_fixed); } else { @@ -196,9 +214,12 @@ void ExitFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { void EntryFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { ASSERT(visitor != nullptr); // Visit objects between SP and (FP - callee_save_area). - ObjectPtr* first = reinterpret_cast(sp()); - ObjectPtr* last = - reinterpret_cast(fp()) + kExitLinkSlotFromEntryFp - 1; + ObjectPtr* first = is_interpreted() ? reinterpret_cast(fp()) + + kKBCSavedArgDescSlotFromEntryFp + : reinterpret_cast(sp()); + ObjectPtr* last = is_interpreted() ? reinterpret_cast(sp()) + : reinterpret_cast(fp()) + + kExitLinkSlotFromEntryFp - 1; // There may not be any pointer to visit; in this case, first > last. visitor->VisitPointers(first, last); } @@ -227,7 +248,9 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { global_table = global_table_payload; } else { ObjectPtr pc_marker = *(reinterpret_cast( - fp() + (runtime_frame_layout.code_from_fp * kWordSize))); + fp() + ((is_interpreted() ? kKBCPcMarkerSlotFromFp + : runtime_frame_layout.code_from_fp) * + kWordSize))); // May forward raw code. Note we don't just visit the pc marker slot first // because the visitor's forwarding might not be idempotent. visitor->VisitPointer(&pc_marker); @@ -241,7 +264,9 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { isolate_group()->object_store()->canonicalized_stack_map_entries(); } } else { - ASSERT(pc_marker == Object::null()); + ASSERT(pc_marker == Object::null() || + (is_interpreted() && (!pc_marker->IsHeapObject() || + (pc_marker->GetClassId() == kBytecodeCid)))); } } @@ -252,6 +277,9 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { maps, global_table); const uint32_t pc_offset = pc() - code_start; if (it.Find(pc_offset)) { + if (is_interpreted()) { + UNIMPLEMENTED(); + } ObjectPtr* first = reinterpret_cast(sp()); ObjectPtr* last = reinterpret_cast( fp() + (runtime_frame_layout.first_local_from_fp * kWordSize)); @@ -315,14 +343,33 @@ void StackFrame::VisitObjectPointers(ObjectPointerVisitor* visitor) { // For normal unoptimized Dart frames and Stub frames each slot // between the first and last included are tagged objects. - ObjectPtr* first = reinterpret_cast(sp()); + if (is_interpreted()) { + // Do not visit caller's pc or caller's fp. + ObjectPtr* first = + reinterpret_cast(fp()) + kKBCFirstObjectSlotFromFp; + ObjectPtr* last = + reinterpret_cast(fp()) + kKBCLastFixedObjectSlotFromFp; + + visitor->VisitPointers(first, last); + } + ObjectPtr* first = + reinterpret_cast(is_interpreted() ? fp() : sp()); ObjectPtr* last = reinterpret_cast( - fp() + (runtime_frame_layout.first_object_from_fp * kWordSize)); + is_interpreted() + ? sp() + : fp() + (runtime_frame_layout.first_object_from_fp * kWordSize)); visitor->VisitPointers(first, last); } FunctionPtr StackFrame::LookupDartFunction() const { + if (is_interpreted()) { + ObjectPtr result = *(reinterpret_cast( + fp() + kKBCFunctionSlotFromFp * kWordSize)); + ASSERT((result == Object::null()) || + (result->GetClassId() == kFunctionCid)); + return static_cast(result); + } const Code& code = Code::Handle(LookupDartCode()); if (!code.IsNull()) { const Object& owner = Object::Handle(code.owner()); @@ -350,6 +397,8 @@ CodePtr StackFrame::LookupDartCode() const { } CodePtr StackFrame::GetCodeObject() const { + ASSERT(!is_interpreted()); + #if defined(DART_PRECOMPILED_RUNTIME) if (FLAG_precompiled_mode) { if (pc() == 0) { @@ -370,6 +419,27 @@ CodePtr StackFrame::GetCodeObject() const { return static_cast(pc_marker); } +BytecodePtr StackFrame::LookupDartBytecode() const { +// We add a no gc scope to ensure that the code below does not trigger +// a GC as we are handling raw object references here. It is possible +// that the code is called while a GC is in progress, that is ok. +#if !defined(HOST_OS_WINDOWS) && !defined(HOST_OS_FUCHSIA) + // On Windows and Fuchsia, the profiler calls this from a separate thread + // where Thread::Current() is NULL, so we cannot create a NoSafepointScope. + NoSafepointScope no_safepoint; +#endif + return GetBytecodeObject(); +} + +BytecodePtr StackFrame::GetBytecodeObject() const { + ASSERT(is_interpreted()); + ObjectPtr pc_marker = *( + reinterpret_cast(fp() + kKBCPcMarkerSlotFromFp * kWordSize)); + ASSERT((pc_marker == Object::null()) || + (pc_marker->GetClassId() == kBytecodeCid)); + return static_cast(pc_marker); +} + bool StackFrame::FindExceptionHandler(Thread* thread, uword* handler_pc, bool* needs_stacktrace, @@ -377,19 +447,28 @@ bool StackFrame::FindExceptionHandler(Thread* thread, bool* is_optimized) const { REUSABLE_CODE_HANDLESCOPE(thread); Code& code = reused_code_handle.Handle(); + REUSABLE_BYTECODE_HANDLESCOPE(thread); + Bytecode& bytecode = reused_bytecode_handle.Handle(); REUSABLE_EXCEPTION_HANDLERS_HANDLESCOPE(thread); ExceptionHandlers& handlers = reused_exception_handlers_handle.Handle(); REUSABLE_PC_DESCRIPTORS_HANDLESCOPE(thread); PcDescriptors& descriptors = reused_pc_descriptors_handle.Handle(); uword start; - code = LookupDartCode(); - if (code.IsNull()) { - return false; // Stub frames do not have exception handlers. + if (is_interpreted()) { + bytecode = LookupDartBytecode(); + ASSERT(!bytecode.IsNull()); + start = bytecode.PayloadStart(); + handlers = bytecode.exception_handlers(); + } else { + code = LookupDartCode(); + if (code.IsNull()) { + return false; // Stub frames do not have exception handlers. + } + start = code.PayloadStart(); + handlers = code.exception_handlers(); + descriptors = code.pc_descriptors(); + *is_optimized = code.is_optimized(); } - start = code.PayloadStart(); - handlers = code.exception_handlers(); - descriptors = code.pc_descriptors(); - *is_optimized = code.is_optimized(); HandlerInfoCache* cache = thread->isolate()->handler_info_cache(); ExceptionHandlerInfo* info = cache->Lookup(pc()); if (info != nullptr) { @@ -401,13 +480,18 @@ bool StackFrame::FindExceptionHandler(Thread* thread, intptr_t try_index = -1; if (handlers.num_entries() != 0) { - uword pc_offset = pc() - code.PayloadStart(); - PcDescriptors::Iterator iter(descriptors, UntaggedPcDescriptors::kAnyKind); - while (iter.MoveNext()) { - const intptr_t current_try_index = iter.TryIndex(); - if ((iter.PcOffset() == pc_offset) && (current_try_index != -1)) { - try_index = current_try_index; - break; + if (is_interpreted()) { + try_index = bytecode.GetTryIndexAtPc(pc()); + } else { + uword pc_offset = pc() - code.PayloadStart(); + PcDescriptors::Iterator iter(descriptors, + UntaggedPcDescriptors::kAnyKind); + while (iter.MoveNext()) { + const intptr_t current_try_index = iter.TryIndex(); + if ((iter.PcOffset() == pc_offset) && (current_try_index != -1)) { + try_index = current_try_index; + break; + } } } } @@ -430,6 +514,13 @@ bool StackFrame::FindExceptionHandler(Thread* thread, } TokenPosition StackFrame::GetTokenPos() const { + if (is_interpreted()) { + const Bytecode& bytecode = Bytecode::Handle(LookupDartBytecode()); + if (bytecode.IsNull()) { + return TokenPosition::kNoSource; // Stub frames do not have token_pos. + } + return bytecode.GetTokenIndexOfPC(pc()); + } const Code& code = Code::Handle(LookupDartCode()); if (code.IsNull()) { return TokenPosition::kNoSource; // Stub frames do not have token_pos. @@ -451,6 +542,9 @@ bool StackFrame::IsValid() const { if (IsEntryFrame() || IsExitFrame() || IsStubFrame()) { return true; } + if (is_interpreted()) { + return (LookupDartBytecode() != Bytecode::null()); + } return (LookupDartCode() != Code::null()); } @@ -471,16 +565,25 @@ void StackFrameIterator::SetupLastExitFrameData() { frames_.fp_ = exit_marker; frames_.sp_ = 0; frames_.pc_ = 0; +#if defined(DART_DYNAMIC_MODULES) + frames_.CheckIfInterpreted(exit_marker); +#endif frames_.Unpoison(); } void StackFrameIterator::SetupNextExitFrameData() { ASSERT(entry_.fp() != 0); - uword exit_address = entry_.fp() + (kExitLinkSlotFromEntryFp * kWordSize); + uword exit_address = + entry_.fp() + ((entry_.is_interpreted() ? kKBCExitLinkSlotFromEntryFp + : kExitLinkSlotFromEntryFp) * + kWordSize); uword exit_marker = *reinterpret_cast(exit_address); frames_.fp_ = exit_marker; frames_.sp_ = 0; frames_.pc_ = 0; +#if defined(DART_DYNAMIC_MODULES) + frames_.CheckIfInterpreted(exit_marker); +#endif frames_.Unpoison(); } @@ -513,6 +616,9 @@ StackFrameIterator::StackFrameIterator(uword last_fp, frames_.fp_ = last_fp; frames_.sp_ = 0; frames_.pc_ = 0; +#if defined(DART_DYNAMIC_MODULES) + frames_.CheckIfInterpreted(last_fp); +#endif frames_.Unpoison(); } @@ -533,6 +639,9 @@ StackFrameIterator::StackFrameIterator(uword fp, frames_.fp_ = fp; frames_.sp_ = sp; frames_.pc_ = pc; +#if defined(DART_DYNAMIC_MODULES) + frames_.CheckIfInterpreted(fp); +#endif frames_.Unpoison(); } @@ -570,8 +679,10 @@ StackFrame* StackFrameIterator::NextFrame() { // Iteration starts from an exit frame given by its fp. current_frame_ = NextExitFrame(); } else if (*(reinterpret_cast( - frames_.fp_ + (kSavedCallerFpSlotFromFp * kWordSize))) == - 0) { + frames_.fp_ + + ((frames_.is_interpreted() ? kKBCSavedCallerFpSlotFromFp + : kSavedCallerFpSlotFromFp) * + kWordSize))) == 0) { // Iteration starts from an entry frame given by its fp, sp, and pc. current_frame_ = NextEntryFrame(); } else { @@ -601,6 +712,15 @@ StackFrame* StackFrameIterator::NextFrame() { return current_frame_; } +#if defined(DART_DYNAMIC_MODULES) +void StackFrameIterator::FrameSetIterator::CheckIfInterpreted( + uword exit_marker) { + Interpreter* interpreter = thread_->interpreter(); + is_interpreted_ = + (interpreter != nullptr) && interpreter->HasFrame(exit_marker); +} +#endif // defined(DART_DYNAMIC_MODULES) + // Tell MemorySanitizer that generated code initializes part of the stack. void StackFrameIterator::FrameSetIterator::Unpoison() { // When using a simulator, all writes to the stack happened from MSAN @@ -610,7 +730,7 @@ void StackFrameIterator::FrameSetIterator::Unpoison() { #if !defined(USING_SIMULATOR) if (fp_ == 0) return; // Note that Thread::os_thread_ is cleared when the thread is descheduled. - ASSERT((thread_->os_thread() == nullptr) || + ASSERT(is_interpreted() || (thread_->os_thread() == nullptr) || ((thread_->os_thread()->stack_limit() < fp_) && (thread_->os_thread()->stack_base() > fp_))); uword lower; @@ -633,10 +753,14 @@ StackFrame* StackFrameIterator::FrameSetIterator::NextFrame(bool validate) { frame->sp_ = sp_; frame->fp_ = fp_; frame->pc_ = pc_; +#if defined(DART_DYNAMIC_MODULES) + frame->is_interpreted_ = is_interpreted(); +#endif sp_ = frame->GetCallerSp(); fp_ = frame->GetCallerFp(); pc_ = frame->GetCallerPc(); Unpoison(); + ASSERT(is_interpreted() == frame->is_interpreted()); ASSERT(!validate || frame->IsValid()); return frame; } @@ -645,10 +769,14 @@ ExitFrame* StackFrameIterator::NextExitFrame() { exit_.sp_ = frames_.sp_; exit_.fp_ = frames_.fp_; exit_.pc_ = frames_.pc_; +#if defined(DART_DYNAMIC_MODULES) + exit_.is_interpreted_ = frames_.is_interpreted(); +#endif frames_.sp_ = exit_.GetCallerSp(); frames_.fp_ = exit_.GetCallerFp(); frames_.pc_ = exit_.GetCallerPc(); frames_.Unpoison(); + ASSERT(frames_.is_interpreted() == exit_.is_interpreted()); ASSERT(!validate_ || exit_.IsValid()); return &exit_; } @@ -658,6 +786,9 @@ EntryFrame* StackFrameIterator::NextEntryFrame() { entry_.sp_ = frames_.sp_; entry_.fp_ = frames_.fp_; entry_.pc_ = frames_.pc_; +#if defined(DART_DYNAMIC_MODULES) + entry_.is_interpreted_ = frames_.is_interpreted(); +#endif SetupNextExitFrameData(); // Setup data for next exit frame in chain. ASSERT(!validate_ || entry_.IsValid()); return &entry_; diff --git a/runtime/vm/stack_frame.h b/runtime/vm/stack_frame.h index e45428a8c3b..d35b4c335e3 100644 --- a/runtime/vm/stack_frame.h +++ b/runtime/vm/stack_frame.h @@ -7,7 +7,9 @@ #include "vm/allocation.h" #include "vm/frame_layout.h" +#include "vm/interpreter.h" #include "vm/object.h" +#include "vm/stack_frame_kbc.h" #include "vm/stub_code.h" #if defined(TARGET_ARCH_IA32) @@ -44,6 +46,7 @@ class StackFrame : public ValueObject { // The pool pointer is not implemented on all architectures. static int SavedCallerPpSlotFromFp() { + // Never called on an interpreter frame. if (runtime_frame_layout.saved_caller_pp_from_fp != kSavedCallerFpSlotFromFp) { return runtime_frame_layout.saved_caller_pp_from_fp; @@ -53,30 +56,37 @@ class StackFrame : public ValueObject { } bool IsMarkedForLazyDeopt() const { + ASSERT(!is_interpreted()); uword raw_pc = *reinterpret_cast(sp() + (kSavedPcSlotFromSp * kWordSize)); return raw_pc == StubCode::DeoptimizeLazyFromReturn().EntryPoint(); } void MarkForLazyDeopt() { + ASSERT(!is_interpreted()); set_pc(StubCode::DeoptimizeLazyFromReturn().EntryPoint()); } void UnmarkForLazyDeopt() { // If this frame was marked for lazy deopt, pc_ was computed to be the // original return address using the pending deopts table in GetCallerPc. // Write this value back into the frame. + ASSERT(!is_interpreted()); uword original_pc = pc(); ASSERT(original_pc != StubCode::DeoptimizeLazyFromReturn().EntryPoint()); set_pc(original_pc); } void set_pc(uword value) { - *reinterpret_cast(sp() + (kSavedPcSlotFromSp * kWordSize)) = value; + *reinterpret_cast(sp() + ((is_interpreted() ? kKBCSavedPcSlotFromSp + : kSavedPcSlotFromSp) * + kWordSize)) = value; pc_ = value; } void set_pc_marker(CodePtr code) { *reinterpret_cast( - fp() + (runtime_frame_layout.code_from_fp * kWordSize)) = code; + fp() + ((is_interpreted() ? kKBCPcMarkerSlotFromFp + : runtime_frame_layout.code_from_fp) * + kWordSize)) = code; } // Visit objects in the frame. @@ -102,8 +112,15 @@ class StackFrame : public ValueObject { virtual bool IsEntryFrame() const { return false; } virtual bool IsExitFrame() const { return false; } +#if defined(DART_DYNAMIC_MODULES) + bool is_interpreted() const { return is_interpreted_; } +#else + bool is_interpreted() const { return false; } +#endif + FunctionPtr LookupDartFunction() const; CodePtr LookupDartCode() const; + BytecodePtr LookupDartBytecode() const; bool FindExceptionHandler(Thread* thread, uword* handler_pc, bool* needs_stacktrace, @@ -114,7 +131,11 @@ class StackFrame : public ValueObject { static void DumpCurrentTrace(); - uword GetCallerSp() const { return fp() + (kCallerSpSlotFromFp * kWordSize); } + uword GetCallerSp() const { + return fp() + + ((is_interpreted() ? kKBCCallerSpSlotFromFp : kCallerSpSlotFromFp) * + kWordSize); + } protected: explicit StackFrame(Thread* thread) @@ -134,15 +155,20 @@ class StackFrame : public ValueObject { private: CodePtr GetCodeObject() const; + BytecodePtr GetBytecodeObject() const; uword GetCallerFp() const { - return *(reinterpret_cast(fp() + - (kSavedCallerFpSlotFromFp * kWordSize))); + return *(reinterpret_cast( + fp() + ((is_interpreted() ? kKBCSavedCallerFpSlotFromFp + : kSavedCallerFpSlotFromFp) * + kWordSize))); } uword GetCallerPc() const { uword raw_pc = *(reinterpret_cast( - fp() + (kSavedCallerPcSlotFromFp * kWordSize))); + fp() + ((is_interpreted() ? kKBCSavedCallerPcSlotFromFp + : kSavedCallerPcSlotFromFp) * + kWordSize))); ASSERT(raw_pc != StubCode::DeoptimizeLazyFromThrow().EntryPoint()); if (raw_pc == StubCode::DeoptimizeLazyFromReturn().EntryPoint()) { return thread_->pending_deopts().FindPendingDeopt(GetCallerFp()); @@ -155,6 +181,10 @@ class StackFrame : public ValueObject { uword pc_; Thread* thread_; +#if defined(DART_DYNAMIC_MODULES) + bool is_interpreted_ = false; +#endif + // The iterators FrameSetIterator and StackFrameIterator set the private // fields fp_ and sp_ when they return the respective frame objects. friend class FrameSetIterator; @@ -192,7 +222,9 @@ class ExitFrame : public StackFrame { // dart code. class EntryFrame : public StackFrame { public: - bool IsValid() const { return StubCode::InInvocationStub(pc()); } + bool IsValid() const { + return StubCode::InInvocationStub(pc(), is_interpreted()); + } bool IsDartFrame(bool validate = true) const { return false; } bool IsStubFrame() const { return false; } bool IsEntryFrame() const { return true; } @@ -261,9 +293,11 @@ class StackFrameIterator { if (fp_ == 0) { return false; } - const uword pc = - *(reinterpret_cast(sp_ + (kSavedPcSlotFromSp * kWordSize))); - return !StubCode::InInvocationStub(pc); + const uword pc = *(reinterpret_cast( + sp_ + + ((is_interpreted() ? kKBCSavedPcSlotFromSp : kSavedPcSlotFromSp) * + kWordSize))); + return !StubCode::InInvocationStub(pc, is_interpreted()); } // Get next non entry/exit frame in the set (assumes a next frame exists). @@ -272,6 +306,14 @@ class StackFrameIterator { private: explicit FrameSetIterator(Thread* thread) : fp_(0), sp_(0), pc_(0), stack_frame_(thread), thread_(thread) {} + +#if defined(DART_DYNAMIC_MODULES) + bool is_interpreted() const { return is_interpreted_; } + void CheckIfInterpreted(uword exit_marker); +#else + bool is_interpreted() const { return false; } +#endif + void Unpoison(); uword fp_; @@ -280,6 +322,10 @@ class StackFrameIterator { StackFrame stack_frame_; // Singleton frame returned by NextFrame(). Thread* thread_; +#if defined(DART_DYNAMIC_MODULES) + bool is_interpreted_ = false; +#endif + friend class StackFrameIterator; DISALLOW_COPY_AND_ASSIGN(FrameSetIterator); }; @@ -299,6 +345,8 @@ class StackFrameIterator { void SetupLastExitFrameData(); void SetupNextExitFrameData(); + void CheckInterpreterExitFrame(uword exit_marker); + bool validate_; // Validate each frame as we traverse the frames. EntryFrame entry_; // Singleton entry frame returned by NextEntryFrame(). ExitFrame exit_; // Singleton exit frame returned by NextExitFrame(). diff --git a/runtime/vm/stack_frame_kbc.h b/runtime/vm/stack_frame_kbc.h new file mode 100644 index 00000000000..e750bb86db5 --- /dev/null +++ b/runtime/vm/stack_frame_kbc.h @@ -0,0 +1,65 @@ +// Copyright (c) 2024, 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_STACK_FRAME_KBC_H_ +#define RUNTIME_VM_STACK_FRAME_KBC_H_ + +#include "platform/globals.h" + +namespace dart { + +/* Kernel Bytecode Frame Layout + +IMPORTANT: KBC stack is growing upwards which is different from all other +architectures. This enables efficient addressing for locals via unsigned index. + + | | <- TOS +Callee frame | ... | + | saved FP | (FP of current frame) + | saved PC | (PC of current frame) + | code object | + | function object | + +--------------------+ +Current frame | ... T| <- SP of current frame + | ... T| + | first local T| <- FP of current frame + | caller's FP | + | caller's PC | + | code object T| (current frame's code object) + | function object T| (current frame's function object) + +--------------------+ +Caller frame | last parameter | <- SP of caller frame + | ... | + + T against a slot indicates it needs to be traversed during GC. +*/ + +static const int kKBCDartFrameFixedSize = 4; // Function, Code, PC, FP +static const int kKBCSavedPcSlotFromSp = 3; + +static const int kKBCFirstObjectSlotFromFp = -4; // Used by GC. +static const int kKBCLastFixedObjectSlotFromFp = -3; + +static const int kKBCSavedCallerFpSlotFromFp = -1; +static const int kKBCSavedCallerPcSlotFromFp = -2; +static const int kKBCCallerSpSlotFromFp = -kKBCDartFrameFixedSize - 1; +static const int kKBCPcMarkerSlotFromFp = -3; +static const int kKBCFunctionSlotFromFp = -4; +static const int kKBCParamEndSlotFromFp = 4; +static const int kKBCSuspendStateSlotFromFp = 0; + +// Entry and exit frame layout. +static const int kKBCEntrySavedSlots = 3; +static const int kKBCExitLinkSlotFromEntryFp = 0; +static const int kKBCSavedArgDescSlotFromEntryFp = 1; +static const int kKBCSavedPpSlotFromEntryFp = 2; + +// Value for stack limit that is used to cause an interrupt. +// Note that on KBC stack is growing upwards so interrupt limit is 0 unlike +// on all other architectures. +static const uword kKBCInterruptStackLimit = 0; + +} // namespace dart + +#endif // RUNTIME_VM_STACK_FRAME_KBC_H_ diff --git a/runtime/vm/stack_trace.cc b/runtime/vm/stack_trace.cc index 01818576f1d..cbfb825de86 100644 --- a/runtime/vm/stack_trace.cc +++ b/runtime/vm/stack_trace.cc @@ -90,6 +90,7 @@ class AsyncAwareStackUnwinder : public ValueObject { encountered_async_catch_error_(encountered_async_catch_error), closure_(Closure::Handle(zone_)), code_(Code::Handle(zone_)), + bytecode_(Bytecode::Handle(zone_)), context_(Context::Handle(zone_)), function_(Function::Handle(zone_)), parent_function_(Function::Handle(zone_)), @@ -100,7 +101,9 @@ class AsyncAwareStackUnwinder : public ValueObject { subscription_(Object::Handle(zone_)), stream_iterator_(Object::Handle(zone_)), async_lib_(Library::Handle(zone_, Library::AsyncLibrary())), - null_closure_(Closure::Handle(zone_)) { + null_closure_(Closure::Handle(zone_)), + null_code_(Code::Handle(zone_)), + null_bytecode_(Bytecode::Handle(zone_)) { if (encountered_async_catch_error_ != nullptr) { *encountered_async_catch_error_ = false; } @@ -259,6 +262,7 @@ class AsyncAwareStackUnwinder : public ValueObject { Closure& closure_; Code& code_; + Bytecode& bytecode_; Context& context_; Function& function_; Function& parent_function_; @@ -275,6 +279,8 @@ class AsyncAwareStackUnwinder : public ValueObject { Field* fields_[kUsedFieldCount] = {}; const Closure& null_closure_; + const Code& null_code_; + const Bytecode& null_bytecode_; DISALLOW_COPY_AND_ASSIGN(AsyncAwareStackUnwinder); }; @@ -294,16 +300,27 @@ void AsyncAwareStackUnwinder::Unwind( while (sync_frame_ != nullptr && awaiter_frame_.closure.IsNull()) { const bool was_handled = HandleSynchronousFrame(); if (!was_handled) { - code_ = sync_frame_->LookupDartCode(); - const uword pc_offset = sync_frame_->pc() - code_.PayloadStart(); - handle_frame({sync_frame_, code_, pc_offset, null_closure_}); + if (sync_frame_->is_interpreted()) { + bytecode_ = sync_frame_->LookupDartBytecode(); + if (bytecode_.function() == Function::null()) { + continue; + } + const uword pc_offset = sync_frame_->pc() - bytecode_.PayloadStart(); + handle_frame( + {sync_frame_, null_code_, bytecode_, pc_offset, null_closure_}); + } else { + code_ = sync_frame_->LookupDartCode(); + const uword pc_offset = sync_frame_->pc() - code_.PayloadStart(); + handle_frame( + {sync_frame_, code_, null_bytecode_, pc_offset, null_closure_}); + } } sync_frame_ = sync_frames_.NextFrame(); } - const StackTraceUtils::Frame gap_frame = {nullptr, - StubCode::AsynchronousGapMarker(), - /*pc_offset=*/0, null_closure_}; + const StackTraceUtils::Frame gap_frame = { + nullptr, StubCode::AsynchronousGapMarker(), null_bytecode_, + /*pc_offset=*/0, null_closure_}; // Traverse awaiter frames. bool any_async = false; @@ -336,7 +353,8 @@ void AsyncAwareStackUnwinder::Unwind( } handle_frame(gap_frame); - handle_frame({nullptr, code_, pc_offset, awaiter_frame_.closure}); + handle_frame( + {nullptr, code_, null_bytecode_, pc_offset, awaiter_frame_.closure}); } if (any_async) { diff --git a/runtime/vm/stack_trace.h b/runtime/vm/stack_trace.h index 7a26238bed6..c16963c547f 100644 --- a/runtime/vm/stack_trace.h +++ b/runtime/vm/stack_trace.h @@ -26,6 +26,9 @@ class StackTraceUtils : public AllStatic { // Code object corresponding to this frame. const Code& code; + // Bytecode object corresponding to this frame. + const Bytecode& bytecode; + // Offset into the code object corresponding to this frame. // // Will be set to |kFutureListenerPcOffset| if this frame corresponds to diff --git a/runtime/vm/stub_code.cc b/runtime/vm/stub_code.cc index dd6181eec38..6347dc0224a 100644 --- a/runtime/vm/stub_code.cc +++ b/runtime/vm/stub_code.cc @@ -9,6 +9,7 @@ #include "vm/compiler/assembler/disassembler.h" #include "vm/flags.h" #include "vm/heap/safepoint.h" +#include "vm/interpreter.h" #include "vm/object_store.h" #include "vm/snapshot.h" #include "vm/virtual_memory.h" @@ -129,8 +130,22 @@ void StubCode::Cleanup() { } } -bool StubCode::InInvocationStub(uword pc) { +bool StubCode::InInvocationStub(uword pc, bool is_interpreted_frame) { ASSERT(HasBeenInitialized()); +#if defined(DART_DYNAMIC_MODULES) + if (is_interpreted_frame) { + // Recognize special marker set up by interpreter in entry frame. + return Interpreter::IsEntryFrameMarker( + reinterpret_cast(pc)); + } + { + uword entry = StubCode::InvokeDartCodeFromBytecode().EntryPoint(); + uword size = StubCode::InvokeDartCodeFromBytecodeSize(); + if ((pc >= entry) && (pc < (entry + size))) { + return true; + } + } +#endif // defined(DART_DYNAMIC_MODULES) uword entry = StubCode::InvokeDartCode().EntryPoint(); uword size = StubCode::InvokeDartCodeSize(); return (pc >= entry) && (pc < (entry + size)); diff --git a/runtime/vm/stub_code.h b/runtime/vm/stub_code.h index 5430b0e0cc3..9f40146910c 100644 --- a/runtime/vm/stub_code.h +++ b/runtime/vm/stub_code.h @@ -47,7 +47,7 @@ class StubCode : public AllStatic { // Check if specified pc is in the dart invocation stub used for // transitioning into dart code. - static bool InInvocationStub(uword pc); + static bool InInvocationStub(uword pc, bool is_interpreted_frame = false); // Check if the specified pc is in the jump to frame stub. static bool InJumpToFrameStub(uword pc); diff --git a/runtime/vm/stub_code_list.h b/runtime/vm/stub_code_list.h index 7297fcf70be..3639968ce5e 100644 --- a/runtime/vm/stub_code_list.h +++ b/runtime/vm/stub_code_list.h @@ -71,6 +71,7 @@ namespace dart { V(CloneContext) \ V(CallToRuntime) \ V(LazyCompile) \ + V(InterpretCall) \ V(CallBootstrapNative) \ V(CallNoScopeNative) \ V(CallAutoScopeNative) \ @@ -78,6 +79,7 @@ namespace dart { V(CallStaticFunction) \ V(OptimizeFunction) \ V(InvokeDartCode) \ + V(InvokeDartCodeFromBytecode) \ V(DebugStepCheck) \ V(SwitchableCallMiss) \ V(MonomorphicSmiableCheck) \ diff --git a/runtime/vm/symbols.h b/runtime/vm/symbols.h index cd8d958e59b..cb61bc95833 100644 --- a/runtime/vm/symbols.h +++ b/runtime/vm/symbols.h @@ -33,6 +33,7 @@ class ObjectPointerVisitor; V(BooleanExpression, "boolean expression") \ V(BoundsCheckForPartialInstantiation, "_boundsCheckForPartialInstantiation") \ V(ByteData, "ByteData") \ + V(Bytecode, "Bytecode") \ V(Capability, "Capability") \ V(CheckLoaded, "_checkLoaded") \ V(Class, "Class") \ diff --git a/runtime/vm/tagged_pointer.h b/runtime/vm/tagged_pointer.h index 01e01f915a9..dbfef137717 100644 --- a/runtime/vm/tagged_pointer.h +++ b/runtime/vm/tagged_pointer.h @@ -377,6 +377,7 @@ DEFINE_TAGGED_POINTER(KernelProgramInfo, Object) DEFINE_TAGGED_POINTER(WeakSerializationReference, Object) DEFINE_TAGGED_POINTER(WeakArray, Object) DEFINE_TAGGED_POINTER(Code, Object) +DEFINE_TAGGED_POINTER(Bytecode, Object) DEFINE_TAGGED_POINTER(ObjectPool, Object) DEFINE_TAGGED_POINTER(Instructions, Object) DEFINE_TAGGED_POINTER(InstructionsSection, Object) diff --git a/runtime/vm/tags.h b/runtime/vm/tags.h index 7276b80911d..bbeb8138881 100644 --- a/runtime/vm/tags.h +++ b/runtime/vm/tags.h @@ -25,6 +25,7 @@ class RuntimeEntry; V(ClassLoading) \ V(CompileParseRegExp) \ V(Dart) \ + V(DartInterpreted) \ V(GCNewSpace) \ V(GCOldSpace) \ V(GCIdle) \ diff --git a/runtime/vm/thread.cc b/runtime/vm/thread.cc index 464c7d15b35..462cd423fcd 100644 --- a/runtime/vm/thread.cc +++ b/runtime/vm/thread.cc @@ -41,6 +41,10 @@ Thread::~Thread() { ASSERT(old_marking_stack_block_ == nullptr); ASSERT(new_marking_stack_block_ == nullptr); ASSERT(deferred_marking_stack_block_ == nullptr); +#if defined(DART_DYNAMIC_MODULES) + delete interpreter_; + interpreter_ = nullptr; +#endif // There should be no top api scopes at this point. ASSERT(api_top_scope() == nullptr); // Delete the reusable api scope if there is one. @@ -981,6 +985,12 @@ void Thread::VisitObjectPointers(ObjectPointerVisitor* visitor, visitor->VisitPointer(reinterpret_cast(&active_stacktrace_)); visitor->VisitPointer(reinterpret_cast(&sticky_error_)); +#if defined(DART_DYNAMIC_MODULES) + if (interpreter() != nullptr) { + interpreter()->VisitObjectPointers(visitor); + } +#endif + // Visit the api local scope as it has all the api local handles. ApiLocalScope* scope = api_top_scope_; while (scope != nullptr) { @@ -1246,6 +1256,11 @@ bool Thread::TopErrorHandlerIsSetJump() const { // False positives: simulator stack and native stack are unordered. return true; #else +#if defined(DART_DYNAMIC_MODULES) + // False positives: interpreter stack and native stack are unordered. + if ((interpreter_ != nullptr) && interpreter_->HasFrame(top_exit_frame_info_)) + return true; +#endif return reinterpret_cast(long_jump_base()) < top_exit_frame_info_; #endif } @@ -1257,6 +1272,11 @@ bool Thread::TopErrorHandlerIsExitFrame() const { // False positives: simulator stack and native stack are unordered. return true; #else +#if defined(DART_DYNAMIC_MODULES) + // False positives: interpreter stack and native stack are unordered. + if ((interpreter_ != nullptr) && interpreter_->HasFrame(top_exit_frame_info_)) + return true; +#endif return top_exit_frame_info_ < reinterpret_cast(long_jump_base()); #endif } diff --git a/runtime/vm/thread.h b/runtime/vm/thread.h index 9c3a2ff668f..37c5928c0e8 100644 --- a/runtime/vm/thread.h +++ b/runtime/vm/thread.h @@ -39,6 +39,7 @@ class CompilerState; class CompilerTimings; class Class; class Code; +class Bytecode; class Error; class ExceptionHandlers; class Field; @@ -49,6 +50,7 @@ class HandleScope; class Heap; class HierarchyInfo; class Instance; +class Interpreter; class Isolate; class IsolateGroup; class Library; @@ -69,6 +71,10 @@ class TypeParameter; class TypeUsageInfo; class Zone; +namespace bytecode { +class BytecodeLoader; +} + namespace compiler { namespace target { class Thread; @@ -80,6 +86,7 @@ class Thread; V(Array) \ V(Class) \ V(Code) \ + V(Bytecode) \ V(Error) \ V(ExceptionHandlers) \ V(Field) \ @@ -104,6 +111,8 @@ class Thread; StubCode::FixAllocationStubTarget().ptr(), nullptr) \ V(CodePtr, invoke_dart_code_stub_, StubCode::InvokeDartCode().ptr(), \ nullptr) \ + V(CodePtr, invoke_dart_code_from_bytecode_stub_, \ + StubCode::InvokeDartCodeFromBytecode().ptr(), nullptr) \ V(CodePtr, call_to_runtime_stub_, StubCode::CallToRuntime().ptr(), nullptr) \ V(CodePtr, late_initialization_error_shared_without_fpu_regs_stub_, \ StubCode::LateInitializationErrorSharedWithoutFPURegs().ptr(), nullptr) \ @@ -247,6 +256,7 @@ class Thread; NativeEntry::NoScopeNativeCallWrapperEntry(), 0) \ V(uword, auto_scope_native_wrapper_entry_point_, \ NativeEntry::AutoScopeNativeCallWrapperEntry(), 0) \ + V(uword, interpret_call_entry_point_, RuntimeEntry::InterpretCallEntry(), 0) \ V(StringPtr*, predefined_symbols_address_, Symbols::PredefinedAddress(), \ nullptr) \ V(uword, double_nan_address_, reinterpret_cast(&double_nan_constant), \ @@ -1154,6 +1164,16 @@ class Thread : public ThreadState { return SafepointLevel::kGCAndDeoptAndReload; } +#if defined(DART_DYNAMIC_MODULES) + Interpreter* interpreter() const { return interpreter_; } + void set_interpreter(Interpreter* value) { interpreter_ = value; } + + bytecode::BytecodeLoader* bytecode_loader() const { return bytecode_loader_; } + void set_bytecode_loader(bytecode::BytecodeLoader* value) { + bytecode_loader_ = value; + } +#endif + private: template T* AllocateReusableHandle(); @@ -1407,6 +1427,11 @@ class Thread : public ThreadState { HeapProfileSampler heap_sampler_; #endif +#if defined(DART_DYNAMIC_MODULES) + Interpreter* interpreter_ = nullptr; + bytecode::BytecodeLoader* bytecode_loader_ = nullptr; +#endif + explicit Thread(bool is_vm_isolate); void StoreBufferRelease( @@ -1472,6 +1497,7 @@ class Thread : public ThreadState { friend class ApiZone; friend class ActiveIsolateScope; + friend class Interpreter; friend class InterruptChecker; friend class Isolate; friend class IsolateGroup; diff --git a/runtime/vm/vm_sources.gni b/runtime/vm/vm_sources.gni index af5ed98b566..4a425261850 100644 --- a/runtime/vm/vm_sources.gni +++ b/runtime/vm/vm_sources.gni @@ -23,6 +23,8 @@ vm_sources = [ "bootstrap_natives.h", "bss_relocs.cc", "bss_relocs.h", + "bytecode_reader.cc", + "bytecode_reader.h", "canonical_tables.cc", "canonical_tables.h", "class_finalizer.cc", @@ -53,6 +55,8 @@ vm_sources = [ "constants_base.h", "constants_ia32.cc", "constants_ia32.h", + "constants_kbc.cc", + "constants_kbc.h", "constants_riscv.cc", "constants_riscv.h", "constants_x64.cc", @@ -138,6 +142,8 @@ vm_sources = [ "instructions_riscv.h", "instructions_x64.cc", "instructions_x64.h", + "interpreter.cc", + "interpreter.h", "intrusive_dlist.h", "isolate.cc", "isolate.h", @@ -311,6 +317,7 @@ vm_sources = [ "stack_frame_arm.h", "stack_frame_arm64.h", "stack_frame_ia32.h", + "stack_frame_kbc.h", "stack_frame_x64.h", "stack_trace.cc", "stack_trace.h", diff --git a/sdk/lib/_internal/vm/lib/internal_patch.dart b/sdk/lib/_internal/vm/lib/internal_patch.dart index 31210a6c973..b19ab053c8c 100644 --- a/sdk/lib/_internal/vm/lib/internal_patch.dart +++ b/sdk/lib/_internal/vm/lib/internal_patch.dart @@ -445,4 +445,7 @@ external String intern(String str); @patch Future loadDynamicModule({Uri? uri, Uint8List? bytes}) => - throw 'Unsupported operation'; + Future.value(_loadDynamicModule(bytes!)); + +@pragma("vm:external-name", "Internal_loadDynamicModule") +external Object? _loadDynamicModule(Uint8List bytes); diff --git a/tools/gn.py b/tools/gn.py index 372063b4f94..9dc23863341 100755 --- a/tools/gn.py +++ b/tools/gn.py @@ -257,6 +257,8 @@ def ToGnArgs(args, mode, arch, target_os, sanitizer, verify_sdk_hash, enable_code_coverage = args.code_coverage and gn_args['is_clang'] gn_args['dart_vm_code_coverage'] = enable_code_coverage + gn_args['dart_dynamic_modules'] = args.dart_dynamic_modules + gn_args['is_asan'] = sanitizer == 'asan' gn_args['is_lsan'] = sanitizer == 'lsan' gn_args['is_msan'] = sanitizer == 'msan' @@ -496,6 +498,11 @@ def AddCommonGnOptionArgs(parser): default=False, dest="code_coverage", action='store_true') + parser.add_argument('--dart-dynamic-modules', + help='Enable Dart dynamic modules.', + default=False, + dest='dart_dynamic_modules', + action='store_true') parser.add_argument('--debug-opt-level', '-d', help='The optimization level to use for debug builds',