From 47e2465545cc20acd90e3044500efdf36a4e5753 Mon Sep 17 00:00:00 2001 From: "zra@google.com" Date: Thu, 12 Jun 2014 19:56:46 +0000 Subject: [PATCH] Begins removing intptr_t from raw object fields. R=asiva@google.com Review URL: https://codereview.chromium.org//328893002 git-svn-id: https://dart.googlecode.com/svn/branches/bleeding_edge/dart@37285 260f80e4-7a28-3924-810f-c04153c831b5 --- runtime/vm/assembler_arm64.h | 18 ++-- runtime/vm/assembler_x64.cc | 6 ++ runtime/vm/assembler_x64.h | 1 + runtime/vm/flow_graph_compiler_arm64.cc | 4 +- runtime/vm/flow_graph_compiler_x64.cc | 12 +-- runtime/vm/intermediate_language_arm64.cc | 52 ++++++----- runtime/vm/intermediate_language_x64.cc | 42 ++++----- runtime/vm/raw_object.h | 46 +++++----- runtime/vm/raw_object_snapshot.cc | 107 +++++++++++----------- runtime/vm/stub_code_arm64.cc | 18 ++-- runtime/vm/stub_code_x64.cc | 8 +- 11 files changed, 165 insertions(+), 149 deletions(-) diff --git a/runtime/vm/assembler_arm64.h b/runtime/vm/assembler_arm64.h index 670f50c1665..9ef8746d881 100644 --- a/runtime/vm/assembler_arm64.h +++ b/runtime/vm/assembler_arm64.h @@ -22,8 +22,6 @@ namespace dart { // Forward declarations. class RuntimeEntry; -// TODO(zra): Label, Address, and FieldAddress are copied from ARM, -// they must be adapted to ARM64. class Label : public ValueObject { public: Label() : position_(0) { } @@ -245,8 +243,8 @@ class Address : public ValueObject { class FieldAddress : public Address { public: - FieldAddress(Register base, int32_t disp) - : Address(base, disp - kHeapObjectTag) { } + FieldAddress(Register base, int32_t disp, OperandSize sz = kDoubleWord) + : Address(base, disp - kHeapObjectTag, Offset, sz) { } FieldAddress(const FieldAddress& other) : Address(other) { } @@ -1071,9 +1069,9 @@ class Assembler : public ValueObject { void LoadFromOffset(Register dest, Register base, int32_t offset, Register pp, OperandSize sz = kDoubleWord); - void LoadFieldFromOffset( - Register dest, Register base, int32_t offset, Register pp) { - LoadFromOffset(dest, base, offset - kHeapObjectTag, pp); + void LoadFieldFromOffset(Register dest, Register base, int32_t offset, + Register pp, OperandSize sz = kDoubleWord) { + LoadFromOffset(dest, base, offset - kHeapObjectTag, pp, sz); } void LoadDFromOffset( VRegister dest, Register base, int32_t offset, Register pp); @@ -1090,9 +1088,9 @@ class Assembler : public ValueObject { void StoreToOffset(Register src, Register base, int32_t offset, Register pp, OperandSize sz = kDoubleWord); - void StoreFieldToOffset( - Register src, Register base, int32_t offset, Register pp) { - StoreToOffset(src, base, offset - kHeapObjectTag, pp); + void StoreFieldToOffset(Register src, Register base, int32_t offset, + Register pp, OperandSize sz = kDoubleWord) { + StoreToOffset(src, base, offset - kHeapObjectTag, pp, sz); } void StoreDToOffset( VRegister src, Register base, int32_t offset, Register pp); diff --git a/runtime/vm/assembler_x64.cc b/runtime/vm/assembler_x64.cc index 1887af0bfdb..f15fab1cda5 100644 --- a/runtime/vm/assembler_x64.cc +++ b/runtime/vm/assembler_x64.cc @@ -240,6 +240,12 @@ void Assembler::movl(const Address& dst, Register src) { } +void Assembler::movl(const Address& dst, const Immediate& imm) { + movl(TMP, imm); + movl(dst, TMP); +} + + void Assembler::movzxb(Register dst, Register src) { AssemblerBuffer::EnsureCapacity ensured(&buffer_); Operand operand(src); diff --git a/runtime/vm/assembler_x64.h b/runtime/vm/assembler_x64.h index 5a141fd08a1..2fdc883b997 100644 --- a/runtime/vm/assembler_x64.h +++ b/runtime/vm/assembler_x64.h @@ -350,6 +350,7 @@ class Assembler : public ValueObject { void movl(Register dst, const Immediate& imm); void movl(Register dst, const Address& src); void movl(const Address& dst, Register src); + void movl(const Address& dst, const Immediate& imm); void movzxb(Register dst, Register src); void movzxb(Register dst, const Address& src); diff --git a/runtime/vm/flow_graph_compiler_arm64.cc b/runtime/vm/flow_graph_compiler_arm64.cc index 66a29de9308..88ad43bbca9 100644 --- a/runtime/vm/flow_graph_compiler_arm64.cc +++ b/runtime/vm/flow_graph_compiler_arm64.cc @@ -974,7 +974,7 @@ void FlowGraphCompiler::EmitFrameEntry() { intptr_t threshold = FLAG_optimization_counter_threshold; __ LoadFieldFromOffset( - R7, function_reg, Function::usage_counter_offset(), new_pp); + R7, function_reg, Function::usage_counter_offset(), new_pp, kWord); if (is_optimizing()) { // Reoptimization of an optimized function is triggered by counting in // IC stubs, but not at the entry of the function. @@ -982,7 +982,7 @@ void FlowGraphCompiler::EmitFrameEntry() { } else { __ add(R7, R7, Operand(1)); __ StoreFieldToOffset( - R7, function_reg, Function::usage_counter_offset(), new_pp); + R7, function_reg, Function::usage_counter_offset(), new_pp, kWord); } __ CompareImmediate(R7, threshold, new_pp); ASSERT(function_reg == R6); diff --git a/runtime/vm/flow_graph_compiler_x64.cc b/runtime/vm/flow_graph_compiler_x64.cc index 0f5a1e54827..46851cb0969 100644 --- a/runtime/vm/flow_graph_compiler_x64.cc +++ b/runtime/vm/flow_graph_compiler_x64.cc @@ -1005,16 +1005,14 @@ void FlowGraphCompiler::EmitFrameEntry() { if (is_optimizing()) { // Reoptimization of an optimized function is triggered by counting in // IC stubs, but not at the entry of the function. - __ CompareImmediate( + __ cmpl( FieldAddress(function_reg, Function::usage_counter_offset()), - Immediate(FLAG_reoptimization_counter_threshold), - new_pp); + Immediate(FLAG_reoptimization_counter_threshold)); } else { - __ incq(FieldAddress(function_reg, Function::usage_counter_offset())); - __ CompareImmediate( + __ incl(FieldAddress(function_reg, Function::usage_counter_offset())); + __ cmpl( FieldAddress(function_reg, Function::usage_counter_offset()), - Immediate(FLAG_optimization_counter_threshold), - new_pp); + Immediate(FLAG_optimization_counter_threshold)); } ASSERT(function_reg == RDI); __ J(GREATER_EQUAL, &StubCode::OptimizeFunctionLabel(), R13); diff --git a/runtime/vm/intermediate_language_arm64.cc b/runtime/vm/intermediate_language_arm64.cc index 9f4cc1300d6..71bc89ec0b2 100644 --- a/runtime/vm/intermediate_language_arm64.cc +++ b/runtime/vm/intermediate_language_arm64.cc @@ -1416,24 +1416,25 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { if (emit_full_guard) { __ LoadObject(field_reg, Field::ZoneHandle(field().raw()), PP); - FieldAddress field_cid_operand(field_reg, Field::guarded_cid_offset()); + FieldAddress field_cid_operand( + field_reg, Field::guarded_cid_offset(), kWord); FieldAddress field_nullability_operand( - field_reg, Field::is_nullable_offset()); + field_reg, Field::is_nullable_offset(), kWord); if (value_cid == kDynamicCid) { LoadValueCid(compiler, value_cid_reg, value_reg); Label skip_length_check; - __ ldr(TMP, field_cid_operand); + __ ldr(TMP, field_cid_operand, kWord); __ CompareRegisters(value_cid_reg, TMP); __ b(&ok, EQ); - __ ldr(TMP, field_nullability_operand); + __ ldr(TMP, field_nullability_operand, kWord); __ CompareRegisters(value_cid_reg, TMP); } else if (value_cid == kNullCid) { - __ ldr(value_cid_reg, field_nullability_operand); + __ ldr(value_cid_reg, field_nullability_operand, kWord); __ CompareImmediate(value_cid_reg, value_cid, PP); } else { Label skip_length_check; - __ ldr(value_cid_reg, field_cid_operand); + __ ldr(value_cid_reg, field_cid_operand, kWord); __ CompareImmediate(value_cid_reg, value_cid, PP); } __ b(&ok, EQ); @@ -1447,17 +1448,17 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { if (!field().needs_length_check()) { // Uninitialized field can be handled inline. Check if the // field is still unitialized. - __ ldr(TMP, field_cid_operand); + __ ldr(TMP, field_cid_operand, kWord); __ CompareImmediate(TMP, kIllegalCid, PP); __ b(fail, NE); if (value_cid == kDynamicCid) { - __ str(value_cid_reg, field_cid_operand); - __ str(value_cid_reg, field_nullability_operand); + __ str(value_cid_reg, field_cid_operand, kWord); + __ str(value_cid_reg, field_nullability_operand, kWord); } else { __ LoadImmediate(TMP, value_cid, PP); - __ str(TMP, field_cid_operand); - __ str(TMP, field_nullability_operand); + __ str(TMP, field_cid_operand, kWord); + __ str(TMP, field_nullability_operand, kWord); } if (deopt == NULL) { @@ -1470,7 +1471,8 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { ASSERT(!compiler->is_optimizing()); __ Bind(fail); - __ LoadFieldFromOffset(TMP, field_reg, Field::guarded_cid_offset(), PP); + __ LoadFieldFromOffset( + TMP, field_reg, Field::guarded_cid_offset(), PP, kWord); __ CompareImmediate(TMP, kDynamicCid, PP); __ b(&ok, EQ); @@ -1737,7 +1739,7 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP); - __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP); + __ LoadFieldFromOffset(temp2, temp, Field::is_nullable_offset(), PP, kWord); __ CompareImmediate(temp2, kNullCid, PP); __ b(&store_pointer, EQ); @@ -1747,15 +1749,15 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ tsti(temp2, 1 << Field::kUnboxingCandidateBit); __ b(&store_pointer, EQ); - __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP); + __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord); __ CompareImmediate(temp2, kDoubleCid, PP); __ b(&store_double, EQ); - __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP); + __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord); __ CompareImmediate(temp2, kFloat32x4Cid, PP); __ b(&store_float32x4, EQ); - __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP); + __ LoadFieldFromOffset(temp2, temp, Field::guarded_cid_offset(), PP, kWord); __ CompareImmediate(temp2, kFloat64x2Cid, PP); __ b(&store_float64x2, EQ); @@ -2124,23 +2126,24 @@ void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ LoadObject(result_reg, Field::ZoneHandle(field()->raw()), PP); - FieldAddress field_cid_operand(result_reg, Field::guarded_cid_offset()); - FieldAddress field_nullability_operand(result_reg, - Field::is_nullable_offset()); + FieldAddress field_cid_operand( + result_reg, Field::guarded_cid_offset(), kWord); + FieldAddress field_nullability_operand( + result_reg, Field::is_nullable_offset(), kWord); - __ ldr(temp, field_nullability_operand); + __ ldr(temp, field_nullability_operand, kWord); __ CompareImmediate(temp, kNullCid, PP); __ b(&load_pointer, EQ); - __ ldr(temp, field_cid_operand); + __ ldr(temp, field_cid_operand, kWord); __ CompareImmediate(temp, kDoubleCid, PP); __ b(&load_double, EQ); - __ ldr(temp, field_cid_operand); + __ ldr(temp, field_cid_operand, kWord); __ CompareImmediate(temp, kFloat32x4Cid, PP); __ b(&load_float32x4, EQ); - __ ldr(temp, field_cid_operand); + __ ldr(temp, field_cid_operand, kWord); __ CompareImmediate(temp, kFloat64x2Cid, PP); __ b(&load_float64x2, EQ); @@ -2475,7 +2478,8 @@ void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ LoadObject(temp, compiler->parsed_function().function(), PP); intptr_t threshold = FLAG_optimization_counter_threshold * (loop_depth() + 1); - __ LoadFieldFromOffset(temp, temp, Function::usage_counter_offset(), PP); + __ LoadFieldFromOffset( + temp, temp, Function::usage_counter_offset(), PP, kWord); __ CompareImmediate(temp, threshold, PP); __ b(slow_path->osr_entry_label(), GE); } diff --git a/runtime/vm/intermediate_language_x64.cc b/runtime/vm/intermediate_language_x64.cc index ffc7abeca33..3665c54698f 100644 --- a/runtime/vm/intermediate_language_x64.cc +++ b/runtime/vm/intermediate_language_x64.cc @@ -1376,13 +1376,13 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { if (value_cid == kDynamicCid) { LoadValueCid(compiler, value_cid_reg, value_reg); - __ cmpq(value_cid_reg, field_cid_operand); + __ cmpl(value_cid_reg, field_cid_operand); __ j(EQUAL, &ok); - __ cmpq(value_cid_reg, field_nullability_operand); + __ cmpl(value_cid_reg, field_nullability_operand); } else if (value_cid == kNullCid) { - __ CompareImmediate(field_nullability_operand, Immediate(value_cid), PP); + __ cmpl(field_nullability_operand, Immediate(value_cid)); } else { - __ CompareImmediate(field_cid_operand, Immediate(value_cid), PP); + __ cmpl(field_cid_operand, Immediate(value_cid)); } __ j(EQUAL, &ok); @@ -1393,16 +1393,16 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { if (!field().needs_length_check()) { // Uninitialized field can be handled inline. Check if the // field is still unitialized. - __ CompareImmediate(field_cid_operand, Immediate(kIllegalCid), PP); + __ cmpl(field_cid_operand, Immediate(kIllegalCid)); __ j(NOT_EQUAL, fail); if (value_cid == kDynamicCid) { - __ movq(field_cid_operand, value_cid_reg); - __ movq(field_nullability_operand, value_cid_reg); + __ movl(field_cid_operand, value_cid_reg); + __ movl(field_nullability_operand, value_cid_reg); } else { ASSERT(field_reg != kNoRegister); - __ LoadImmediate(field_cid_operand, Immediate(value_cid), PP); - __ LoadImmediate(field_nullability_operand, Immediate(value_cid), PP); + __ movl(field_cid_operand, Immediate(value_cid)); + __ movl(field_nullability_operand, Immediate(value_cid)); } if (deopt == NULL) { @@ -1415,8 +1415,8 @@ void GuardFieldClassInstr::EmitNativeCode(FlowGraphCompiler* compiler) { ASSERT(!compiler->is_optimizing()); __ Bind(fail); - __ CompareImmediate(FieldAddress(field_reg, Field::guarded_cid_offset()), - Immediate(kDynamicCid), PP); + __ cmpl(FieldAddress(field_reg, Field::guarded_cid_offset()), + Immediate(kDynamicCid)); __ j(EQUAL, &ok); __ pushq(field_reg); @@ -1685,7 +1685,7 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ LoadObject(temp, Field::ZoneHandle(field().raw()), PP); - __ cmpq(FieldAddress(temp, Field::is_nullable_offset()), + __ cmpl(FieldAddress(temp, Field::is_nullable_offset()), Immediate(kNullCid)); __ j(EQUAL, &store_pointer); @@ -1693,11 +1693,11 @@ void StoreInstanceFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ testq(temp2, Immediate(1 << Field::kUnboxingCandidateBit)); __ j(ZERO, &store_pointer); - __ cmpq(FieldAddress(temp, Field::guarded_cid_offset()), + __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()), Immediate(kDoubleCid)); __ j(EQUAL, &store_double); - __ cmpq(FieldAddress(temp, Field::guarded_cid_offset()), + __ cmpl(FieldAddress(temp, Field::guarded_cid_offset()), Immediate(kFloat32x4Cid)); __ j(EQUAL, &store_float32x4); @@ -2187,19 +2187,19 @@ void LoadFieldInstr::EmitNativeCode(FlowGraphCompiler* compiler) { __ LoadObject(result, Field::ZoneHandle(field()->raw()), PP); - __ cmpq(FieldAddress(result, Field::is_nullable_offset()), + __ cmpl(FieldAddress(result, Field::is_nullable_offset()), Immediate(kNullCid)); __ j(EQUAL, &load_pointer); - __ cmpq(FieldAddress(result, Field::guarded_cid_offset()), + __ cmpl(FieldAddress(result, Field::guarded_cid_offset()), Immediate(kDoubleCid)); __ j(EQUAL, &load_double); - __ cmpq(FieldAddress(result, Field::guarded_cid_offset()), + __ cmpl(FieldAddress(result, Field::guarded_cid_offset()), Immediate(kFloat32x4Cid)); __ j(EQUAL, &load_float32x4); - __ cmpq(FieldAddress(result, Field::guarded_cid_offset()), + __ cmpl(FieldAddress(result, Field::guarded_cid_offset()), Immediate(kFloat64x2Cid)); __ j(EQUAL, &load_float64x2); @@ -2542,10 +2542,10 @@ void CheckStackOverflowInstr::EmitNativeCode(FlowGraphCompiler* compiler) { // stack checks. Use progressively higher thresholds for more deeply // nested loops to attempt to hit outer loops with OSR when possible. __ LoadObject(temp, compiler->parsed_function().function(), PP); - intptr_t threshold = + int32_t threshold = FLAG_optimization_counter_threshold * (loop_depth() + 1); - __ CompareImmediate(FieldAddress(temp, Function::usage_counter_offset()), - Immediate(threshold), PP); + __ cmpl(FieldAddress(temp, Function::usage_counter_offset()), + Immediate(threshold)); __ j(GREATER_EQUAL, slow_path->osr_entry_label()); } if (compiler->ForceSlowPathForStackOverflow()) { diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h index d55b0436d5c..374943824f4 100644 --- a/runtime/vm/raw_object.h +++ b/runtime/vm/raw_object.h @@ -507,10 +507,10 @@ class RawClass : public RawObject { cpp_vtable handle_vtable_; intptr_t id_; // Class Id, also index in the class table. - intptr_t token_pos_; - intptr_t instance_size_in_words_; // Size if fixed len or 0 if variable len. - intptr_t type_arguments_field_offset_in_words_; // Offset of type args fld. - intptr_t next_field_offset_in_words_; // Offset of the next instance field. + int32_t token_pos_; + int32_t instance_size_in_words_; // Size if fixed len or 0 if variable len. + int32_t type_arguments_field_offset_in_words_; // Offset of type args fld. + int32_t next_field_offset_in_words_; // Offset of the next instance field. int16_t num_type_arguments_; // Number of type arguments in flatten vector. int16_t num_own_type_arguments_; // Number of non-overlapping type arguments. uint16_t num_native_fields_; // Number of native fields in class. @@ -535,7 +535,7 @@ class RawUnresolvedClass : public RawObject { RawObject** to() { return reinterpret_cast(&ptr()->ident_); } - intptr_t token_pos_; + int32_t token_pos_; }; @@ -624,9 +624,9 @@ class RawFunction : public RawObject { return reinterpret_cast(&ptr()->data_); } - intptr_t token_pos_; - intptr_t end_token_pos_; - intptr_t usage_counter_; // Incremented while function is running. + int32_t token_pos_; + int32_t end_token_pos_; + int32_t usage_counter_; // Incremented while function is running. int16_t num_fixed_parameters_; int16_t num_optional_parameters_; // > 0: positional; < 0: named. int16_t deoptimization_counter_; @@ -684,10 +684,10 @@ class RawField : public RawObject { return reinterpret_cast(&ptr()->guarded_list_length_); } - intptr_t token_pos_; - intptr_t guarded_cid_; - intptr_t is_nullable_; // kNullCid if field can contain null value and - // any other value otherwise. + int32_t token_pos_; + int32_t guarded_cid_; + int32_t is_nullable_; // kNullCid if field can contain null value and + // any other value otherwise. // Offset to the guarded length field inside an instance of class matching // guarded_cid_. Stored corrected by -kHeapObjectTag to simplify code // generated on platforms with weak addressing modes (ARM, MIPS). @@ -749,8 +749,8 @@ class RawScript : public RawObject { RawTokenStream* tokens_; RawObject** to() { return reinterpret_cast(&ptr()->tokens_); } - intptr_t line_offset_; - intptr_t col_offset_; + int32_t line_offset_; + int32_t col_offset_; int8_t kind_; // Of type Kind. }; @@ -781,9 +781,9 @@ class RawLibrary : public RawObject { return reinterpret_cast(&ptr()->loaded_scripts_); } - intptr_t index_; // Library id number. - intptr_t num_imports_; // Number of entries in imports_. - intptr_t num_anonymous_; // Number of entries in anonymous_classes_. + int32_t index_; // Library id number. + int32_t num_imports_; // Number of entries in imports_. + int32_t num_anonymous_; // Number of entries in anonymous_classes_. Dart_NativeEntryResolver native_entry_resolver_; // Resolves natives. Dart_NativeEntrySymbol native_entry_symbol_resolver_; bool corelib_imported_; @@ -1066,7 +1066,7 @@ class RawMegamorphicCache : public RawObject { return reinterpret_cast(&ptr()->mask_); } - intptr_t filled_entry_count_; + int32_t filled_entry_count_; }; @@ -1107,7 +1107,7 @@ class RawLanguageError : public RawError { RawObject** to() { return reinterpret_cast(&ptr()->formatted_message_); } - intptr_t token_pos_; // Source position in script_. + int32_t token_pos_; // Source position in script_. int8_t kind_; // Of type LanguageError::Kind. }; @@ -1155,7 +1155,7 @@ class RawLibraryPrefix : public RawInstance { RawObject** to() { return reinterpret_cast(&ptr()->dependent_code_); } - intptr_t num_imports_; // Number of library entries in libraries_. + int32_t num_imports_; // Number of library entries in libraries_. bool is_deferred_load_; bool is_loaded_; }; @@ -1191,7 +1191,7 @@ class RawType : public RawAbstractType { RawObject** to() { return reinterpret_cast(&ptr()->error_); } - intptr_t token_pos_; + int32_t token_pos_; int8_t type_state_; }; @@ -1221,8 +1221,8 @@ class RawTypeParameter : public RawAbstractType { RawString* name_; RawAbstractType* bound_; // ObjectType if no explicit bound specified. RawObject** to() { return reinterpret_cast(&ptr()->bound_); } - intptr_t index_; - intptr_t token_pos_; + int32_t index_; + int32_t token_pos_; int8_t type_state_; }; diff --git a/runtime/vm/raw_object_snapshot.cc b/runtime/vm/raw_object_snapshot.cc index ca49d48b2cc..26ded8331fb 100644 --- a/runtime/vm/raw_object_snapshot.cc +++ b/runtime/vm/raw_object_snapshot.cc @@ -39,7 +39,7 @@ RawClass* Class::ReadFrom(SnapshotReader* reader, if ((kind == Snapshot::kFull) || (kind == Snapshot::kScript && !RawObject::IsCreatedFromSnapshot(tags))) { // Read in the base information. - intptr_t class_id = reader->ReadIntptrValue(); + int32_t class_id = reader->Read(); // Allocate class object of specified kind. if (kind == Snapshot::kFull) { @@ -60,14 +60,14 @@ RawClass* Class::ReadFrom(SnapshotReader* reader, // Set all non object fields. if (!RawObject::IsInternalVMdefinedClassId(class_id)) { // Instance size of a VM defined class is already set up. - cls.set_instance_size_in_words(reader->ReadIntptrValue()); - cls.set_next_field_offset_in_words(reader->ReadIntptrValue()); + cls.set_instance_size_in_words(reader->Read()); + cls.set_next_field_offset_in_words(reader->Read()); } - cls.set_type_arguments_field_offset_in_words(reader->ReadIntptrValue()); + cls.set_type_arguments_field_offset_in_words(reader->Read()); cls.set_num_type_arguments(reader->Read()); cls.set_num_own_type_arguments(reader->Read()); cls.set_num_native_fields(reader->Read()); - cls.set_token_pos(reader->ReadIntptrValue()); + cls.set_token_pos(reader->Read()); cls.set_state_bits(reader->Read()); // Set all the object fields. @@ -101,20 +101,20 @@ void RawClass::WriteTo(SnapshotWriter* writer, // Write out all the non object pointer fields. // NOTE: cpp_vtable_ is not written. - intptr_t class_id = ptr()->id_; - writer->WriteIntptrValue(class_id); + int32_t class_id = ptr()->id_; + writer->Write(class_id); if (!RawObject::IsInternalVMdefinedClassId(class_id)) { // We don't write the instance size of VM defined classes as they // are already setup during initialization as part of pre populating // the class table. - writer->WriteIntptrValue(ptr()->instance_size_in_words_); - writer->WriteIntptrValue(ptr()->next_field_offset_in_words_); + writer->Write(ptr()->instance_size_in_words_); + writer->Write(ptr()->next_field_offset_in_words_); } - writer->WriteIntptrValue(ptr()->type_arguments_field_offset_in_words_); + writer->Write(ptr()->type_arguments_field_offset_in_words_); writer->Write(ptr()->num_type_arguments_); writer->Write(ptr()->num_own_type_arguments_); writer->Write(ptr()->num_native_fields_); - writer->WriteIntptrValue(ptr()->token_pos_); + writer->Write(ptr()->token_pos_); writer->Write(ptr()->state_bits_); // Write out all the object pointer fields. @@ -141,7 +141,7 @@ RawUnresolvedClass* UnresolvedClass::ReadFrom(SnapshotReader* reader, unresolved_class.set_tags(tags); // Set all non object fields. - unresolved_class.set_token_pos(reader->ReadIntptrValue()); + unresolved_class.set_token_pos(reader->Read()); // Set all the object fields. // TODO(5411462): Need to assert No GC can happen here, even though @@ -170,7 +170,7 @@ void RawUnresolvedClass::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object pointer fields. - writer->WriteIntptrValue(ptr()->token_pos_); + writer->Write(ptr()->token_pos_); // Write out all the object pointer fields. SnapshotWriterVisitor visitor(writer); @@ -205,7 +205,7 @@ RawType* Type::ReadFrom(SnapshotReader* reader, reader->AddBackRef(object_id, &type, kIsDeserialized); // Set all non object fields. - type.set_token_pos(reader->ReadIntptrValue()); + type.set_token_pos(reader->Read()); type.set_type_state(reader->Read()); // Set all the object fields. @@ -256,7 +256,7 @@ void RawType::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object pointer fields. - writer->WriteIntptrValue(ptr()->token_pos_); + writer->Write(ptr()->token_pos_); writer->Write(ptr()->type_state_); // Write out all the object pointer fields. Since we will be canonicalizing @@ -328,8 +328,8 @@ RawTypeParameter* TypeParameter::ReadFrom(SnapshotReader* reader, type_parameter.set_tags(tags); // Set all non object fields. - type_parameter.set_index(reader->ReadIntptrValue()); - type_parameter.set_token_pos(reader->ReadIntptrValue()); + type_parameter.set_index(reader->Read()); + type_parameter.set_token_pos(reader->Read()); type_parameter.set_type_state(reader->Read()); // Set all the object fields. @@ -363,8 +363,8 @@ void RawTypeParameter::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object pointer fields. - writer->WriteIntptrValue(ptr()->index_); - writer->WriteIntptrValue(ptr()->token_pos_); + writer->Write(ptr()->index_); + writer->Write(ptr()->token_pos_); writer->Write(ptr()->type_state_); // Write out all the object pointer fields. @@ -692,12 +692,12 @@ RawFunction* Function::ReadFrom(SnapshotReader* reader, func.set_tags(tags); // Set all the non object fields. - func.set_token_pos(reader->ReadIntptrValue()); - func.set_end_token_pos(reader->ReadIntptrValue()); - func.set_usage_counter(reader->ReadIntptrValue()); - func.set_num_fixed_parameters(reader->ReadIntptrValue()); - func.set_num_optional_parameters(reader->ReadIntptrValue()); - func.set_deoptimization_counter(reader->ReadIntptrValue()); + func.set_token_pos(reader->Read()); + func.set_end_token_pos(reader->Read()); + func.set_usage_counter(reader->Read()); + func.set_num_fixed_parameters(reader->Read()); + func.set_num_optional_parameters(reader->Read()); + func.set_deoptimization_counter(reader->Read()); func.set_kind_tag(reader->Read()); func.set_optimized_instruction_count(reader->Read()); func.set_optimized_call_site_count(reader->Read()); @@ -705,13 +705,14 @@ RawFunction* Function::ReadFrom(SnapshotReader* reader, // Set all the object fields. // TODO(5411462): Need to assert No GC can happen here, even though // allocations may happen. - intptr_t num_flds = (func.raw()->to_snapshot() - func.raw()->from()); + intptr_t num_flds = (func.raw()->to() - func.raw()->from()); for (intptr_t i = 0; i <= num_flds; i++) { *(func.raw()->from() + i) = reader->ReadObjectRef(); } - // Initialize all fields that are not part of the snapshot. - func.ClearCode(); + // Set up code pointer with the lazy-compile-stub. + func.SetInstructions(Code::Handle(StubCode::LazyCompile_entry()->code())); + return func.raw(); } @@ -732,19 +733,23 @@ void RawFunction::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object fields. - writer->WriteIntptrValue(ptr()->token_pos_); - writer->WriteIntptrValue(ptr()->end_token_pos_); - writer->WriteIntptrValue(ptr()->usage_counter_); - writer->WriteIntptrValue(ptr()->num_fixed_parameters_); - writer->WriteIntptrValue(ptr()->num_optional_parameters_); - writer->WriteIntptrValue(ptr()->deoptimization_counter_); + writer->Write(ptr()->token_pos_); + writer->Write(ptr()->end_token_pos_); + writer->Write(ptr()->usage_counter_); + writer->Write(ptr()->num_fixed_parameters_); + writer->Write(ptr()->num_optional_parameters_); + writer->Write(ptr()->deoptimization_counter_); writer->Write(ptr()->kind_tag_); writer->Write(ptr()->optimized_instruction_count_); writer->Write(ptr()->optimized_call_site_count_); // Write out all the object pointer fields. SnapshotWriterVisitor visitor(writer); - visitor.VisitPointers(from(), to_snapshot()); + visitor.VisitPointers(from(), to_no_code()); + + // Write null for the instructions and unoptimized code. + writer->WriteVMIsolateObject(kNullObject); + writer->WriteVMIsolateObject(kNullObject); } @@ -765,9 +770,9 @@ RawField* Field::ReadFrom(SnapshotReader* reader, field.set_tags(tags); // Set all non object fields. - field.set_token_pos(reader->ReadIntptrValue()); - field.set_guarded_cid(reader->ReadIntptrValue()); - field.set_is_nullable(reader->ReadIntptrValue()); + field.set_token_pos(reader->Read()); + field.set_guarded_cid(reader->Read()); + field.set_is_nullable(reader->Read()); field.set_kind_bits(reader->Read()); // Set all the object fields. @@ -800,9 +805,9 @@ void RawField::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object fields. - writer->WriteIntptrValue(ptr()->token_pos_); - writer->WriteIntptrValue(ptr()->guarded_cid_); - writer->WriteIntptrValue(ptr()->is_nullable_); + writer->Write(ptr()->token_pos_); + writer->Write(ptr()->guarded_cid_); + writer->Write(ptr()->is_nullable_); writer->Write(ptr()->kind_bits_); // Write out all the object pointer fields. @@ -1011,9 +1016,9 @@ RawLibrary* Library::ReadFrom(SnapshotReader* reader, library.set_tags(tags); // Set all non object fields. - library.raw_ptr()->index_ = reader->ReadIntptrValue(); - library.raw_ptr()->num_imports_ = reader->ReadIntptrValue(); - library.raw_ptr()->num_anonymous_ = reader->ReadIntptrValue(); + library.raw_ptr()->index_ = reader->Read(); + library.raw_ptr()->num_imports_ = reader->Read(); + library.raw_ptr()->num_anonymous_ = reader->Read(); library.raw_ptr()->corelib_imported_ = reader->Read(); library.raw_ptr()->is_dart_scheme_ = reader->Read(); library.raw_ptr()->debuggable_ = reader->Read(); @@ -1066,9 +1071,9 @@ void RawLibrary::WriteTo(SnapshotWriter* writer, writer->WriteObjectImpl(ptr()->url_); } else { // Write out all non object fields. - writer->WriteIntptrValue(ptr()->index_); - writer->WriteIntptrValue(ptr()->num_imports_); - writer->WriteIntptrValue(ptr()->num_anonymous_); + writer->Write(ptr()->index_); + writer->Write(ptr()->num_imports_); + writer->Write(ptr()->num_anonymous_); writer->Write(ptr()->corelib_imported_); writer->Write(ptr()->is_dart_scheme_); writer->Write(ptr()->debuggable_); @@ -1108,7 +1113,7 @@ RawLibraryPrefix* LibraryPrefix::ReadFrom(SnapshotReader* reader, prefix.set_tags(tags); // Set all non object fields. - prefix.raw_ptr()->num_imports_ = reader->ReadIntptrValue(); + prefix.raw_ptr()->num_imports_ = reader->Read(); prefix.raw_ptr()->is_deferred_load_ = reader->Read(); prefix.raw_ptr()->is_loaded_ = reader->Read(); @@ -1140,7 +1145,7 @@ void RawLibraryPrefix::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all non object fields. - writer->WriteIntptrValue(ptr()->num_imports_); + writer->Write(ptr()->num_imports_); writer->Write(ptr()->is_deferred_load_); writer->Write(ptr()->is_loaded_); @@ -1514,7 +1519,7 @@ RawLanguageError* LanguageError::ReadFrom(SnapshotReader* reader, language_error.set_tags(tags); // Set all non object fields. - language_error.set_token_pos(reader->ReadIntptrValue()); + language_error.set_token_pos(reader->Read()); language_error.set_kind(reader->Read()); // Set all the object fields. @@ -1545,7 +1550,7 @@ void RawLanguageError::WriteTo(SnapshotWriter* writer, writer->WriteIntptrValue(writer->GetObjectTags(this)); // Write out all the non object fields. - writer->WriteIntptrValue(ptr()->token_pos_); + writer->Write(ptr()->token_pos_); writer->Write(ptr()->kind_); // Write out all the object pointer fields. diff --git a/runtime/vm/stub_code_arm64.cc b/runtime/vm/stub_code_arm64.cc index 538cc2cc743..4a5302f7b02 100644 --- a/runtime/vm/stub_code_arm64.cc +++ b/runtime/vm/stub_code_arm64.cc @@ -1292,9 +1292,11 @@ void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) { __ Pop(R6); // Restore. __ LeaveStubFrame(); } - __ LoadFieldFromOffset(R7, func_reg, Function::usage_counter_offset(), kNoPP); + __ LoadFieldFromOffset( + R7, func_reg, Function::usage_counter_offset(), kNoPP, kWord); __ add(R7, R7, Operand(1)); - __ StoreFieldToOffset(R7, func_reg, Function::usage_counter_offset(), kNoPP); + __ StoreFieldToOffset( + R7, func_reg, Function::usage_counter_offset(), kNoPP, kWord); } @@ -1305,9 +1307,11 @@ void StubCode::GenerateUsageCounterIncrement(Assembler* assembler, Register func_reg = temp_reg; ASSERT(temp_reg == R6); __ LoadFieldFromOffset(func_reg, ic_reg, ICData::owner_offset(), kNoPP); - __ LoadFieldFromOffset(R7, func_reg, Function::usage_counter_offset(), kNoPP); + __ LoadFieldFromOffset( + R7, func_reg, Function::usage_counter_offset(), kNoPP, kWord); __ AddImmediate(R7, R7, 1, kNoPP); - __ StoreFieldToOffset(R7, func_reg, Function::usage_counter_offset(), kNoPP); + __ StoreFieldToOffset( + R7, func_reg, Function::usage_counter_offset(), kNoPP, kWord); } @@ -1360,7 +1364,7 @@ void StubCode::GenerateNArgsCheckInlineCacheStub( // Load arguments descriptor into R4. __ LoadFieldFromOffset(R4, R5, ICData::arguments_descriptor_offset(), kNoPP); // Loop that checks if there is an IC data match. - Label loop, update, test, found, get_class_id_as_smi; + Label loop, update, test, found; // R5: IC data object (preserved). __ LoadFieldFromOffset(R6, R5, ICData::ic_data_offset(), kNoPP); // R6: ic_data_array with check entries: classes and target functions. @@ -1677,8 +1681,8 @@ static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) { // Compute instance type arguments into R4. Label has_no_type_arguments; __ LoadObject(R4, Object::null_object(), PP); - __ LoadFieldFromOffset( - R5, R3, Class::type_arguments_field_offset_in_words_offset(), kNoPP); + __ LoadFieldFromOffset(R5, R3, + Class::type_arguments_field_offset_in_words_offset(), kNoPP, kWord); __ CompareImmediate(R5, Class::kNoTypeArguments, kNoPP); __ b(&has_no_type_arguments, EQ); __ add(R5, R0, Operand(R5, LSL, 3)); diff --git a/runtime/vm/stub_code_x64.cc b/runtime/vm/stub_code_x64.cc index 08bf4754bed..e3213769d71 100644 --- a/runtime/vm/stub_code_x64.cc +++ b/runtime/vm/stub_code_x64.cc @@ -1221,7 +1221,7 @@ void StubCode::GenerateOptimizedUsageCounterIncrement(Assembler* assembler) { __ popq(func_reg); // Restore. __ LeaveStubFrame(); } - __ incq(FieldAddress(func_reg, Function::usage_counter_offset())); + __ incl(FieldAddress(func_reg, Function::usage_counter_offset())); } @@ -1232,7 +1232,7 @@ void StubCode::GenerateUsageCounterIncrement(Assembler* assembler, Register func_reg = temp_reg; ASSERT(ic_reg != func_reg); __ movq(func_reg, FieldAddress(ic_reg, ICData::owner_offset())); - __ incq(FieldAddress(func_reg, Function::usage_counter_offset())); + __ incl(FieldAddress(func_reg, Function::usage_counter_offset())); } @@ -1600,9 +1600,9 @@ static void GenerateSubtypeNTestCacheStub(Assembler* assembler, int n) { // Compute instance type arguments into R13. Label has_no_type_arguments; __ movq(R13, R12); - __ movq(RDI, FieldAddress(R10, + __ movl(RDI, FieldAddress(R10, Class::type_arguments_field_offset_in_words_offset())); - __ cmpq(RDI, Immediate(Class::kNoTypeArguments)); + __ cmpl(RDI, Immediate(Class::kNoTypeArguments)); __ j(EQUAL, &has_no_type_arguments, Assembler::kNearJump); __ movq(R13, FieldAddress(RAX, RDI, TIMES_8, 0)); __ Bind(&has_no_type_arguments);