| // Copyright 2018 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_ISOLATE_DATA_H_ |
| #define V8_ISOLATE_DATA_H_ |
| |
| #include "src/builtins/builtins.h" |
| #include "src/constants-arch.h" |
| #include "src/external-reference-table.h" |
| #include "src/roots.h" |
| #include "src/thread-local-top.h" |
| #include "src/utils.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| class Isolate; |
| |
| // This class contains a collection of data accessible from both C++ runtime |
| // and compiled code (including assembly stubs, builtins, interpreter bytecode |
| // handlers and optimized code). |
| // In particular, it contains pointer to the V8 heap roots table, external |
| // reference table and builtins array. |
| // The compiled code accesses the isolate data fields indirectly via the root |
| // register. |
| class IsolateData final { |
| public: |
| IsolateData() = default; |
| |
| static constexpr intptr_t kIsolateRootBias = kRootRegisterBias; |
| |
| // The value of the kRootRegister. |
| Address isolate_root() const { |
| return reinterpret_cast<Address>(this) + kIsolateRootBias; |
| } |
| |
| // Root-register-relative offset of the roots table. |
| static constexpr int roots_table_offset() { |
| return kRootsTableOffset - kIsolateRootBias; |
| } |
| |
| // Root-register-relative offset of the given root table entry. |
| static constexpr int root_slot_offset(RootIndex root_index) { |
| return roots_table_offset() + RootsTable::offset_of(root_index); |
| } |
| |
| // Root-register-relative offset of the external reference table. |
| static constexpr int external_reference_table_offset() { |
| return kExternalReferenceTableOffset - kIsolateRootBias; |
| } |
| |
| // Root-register-relative offset of the builtin entry table. |
| static constexpr int builtin_entry_table_offset() { |
| return kBuiltinEntryTableOffset - kIsolateRootBias; |
| } |
| |
| // Root-register-relative offset of the builtins table. |
| static constexpr int builtins_table_offset() { |
| return kBuiltinsTableOffset - kIsolateRootBias; |
| } |
| |
| // Root-register-relative offset of the given builtin table entry. |
| // TODO(ishell): remove in favour of typified id version. |
| static int builtin_slot_offset(int builtin_index) { |
| DCHECK(Builtins::IsBuiltinId(builtin_index)); |
| return builtins_table_offset() + builtin_index * kSystemPointerSize; |
| } |
| |
| // Root-register-relative offset of the builtin table entry. |
| static int builtin_slot_offset(Builtins::Name id) { |
| return builtins_table_offset() + id * kSystemPointerSize; |
| } |
| |
| // Root-register-relative offset of the virtual call target register value. |
| static constexpr int virtual_call_target_register_offset() { |
| return kVirtualCallTargetRegisterOffset - kIsolateRootBias; |
| } |
| |
| // The FP and PC that are saved right before TurboAssembler::CallCFunction. |
| Address* fast_c_call_caller_fp_address() { return &fast_c_call_caller_fp_; } |
| Address* fast_c_call_caller_pc_address() { return &fast_c_call_caller_pc_; } |
| Address fast_c_call_caller_fp() { return fast_c_call_caller_fp_; } |
| Address fast_c_call_caller_pc() { return fast_c_call_caller_pc_; } |
| |
| // Returns true if this address points to data stored in this instance. |
| // If it's the case then the value can be accessed indirectly through the |
| // root register. |
| bool contains(Address address) const { |
| STATIC_ASSERT(std::is_unsigned<Address>::value); |
| Address start = reinterpret_cast<Address>(this); |
| return (address - start) < sizeof(*this); |
| } |
| |
| ThreadLocalTop& thread_local_top() { return thread_local_top_; } |
| ThreadLocalTop const& thread_local_top() const { return thread_local_top_; } |
| |
| RootsTable& roots() { return roots_; } |
| const RootsTable& roots() const { return roots_; } |
| |
| ExternalReferenceTable* external_reference_table() { |
| return &external_reference_table_; |
| } |
| |
| Address* builtin_entry_table() { return builtin_entry_table_; } |
| Address* builtins() { return builtins_; } |
| |
| private: |
| // Static layout definition. |
| #define FIELDS(V) \ |
| V(kEmbedderDataOffset, Internals::kNumIsolateDataSlots* kSystemPointerSize) \ |
| V(kExternalMemoryOffset, kInt64Size) \ |
| V(kExternalMemoryLlimitOffset, kInt64Size) \ |
| V(kExternalMemoryAtLastMarkCompactOffset, kInt64Size) \ |
| V(kRootsTableOffset, RootsTable::kEntriesCount* kSystemPointerSize) \ |
| V(kExternalReferenceTableOffset, ExternalReferenceTable::kSizeInBytes) \ |
| V(kThreadLocalTopOffset, ThreadLocalTop::kSizeInBytes) \ |
| V(kBuiltinEntryTableOffset, Builtins::builtin_count* kSystemPointerSize) \ |
| V(kBuiltinsTableOffset, Builtins::builtin_count* kSystemPointerSize) \ |
| V(kVirtualCallTargetRegisterOffset, kSystemPointerSize) \ |
| V(kFastCCallCallerFPOffset, kSystemPointerSize) \ |
| V(kFastCCallCallerPCOffset, kSystemPointerSize) \ |
| /* This padding aligns IsolateData size by 8 bytes. */ \ |
| V(kPaddingOffset, \ |
| 8 + RoundUp<8>(static_cast<int>(kPaddingOffset)) - kPaddingOffset) \ |
| /* Total size. */ \ |
| V(kSize, 0) |
| |
| DEFINE_FIELD_OFFSET_CONSTANTS(0, FIELDS) |
| #undef FIELDS |
| |
| // These fields are accessed through the API, offsets must be kept in sync |
| // with v8::internal::Internals (in include/v8-internal.h) constants. |
| // The layout consitency is verified in Isolate::CheckIsolateLayout() using |
| // runtime checks. |
| void* embedder_data_[Internals::kNumIsolateDataSlots] = {}; |
| |
| // TODO(ishell): Move these external memory counters back to Heap once the |
| // Node JS bot issue is solved. |
| // The amount of external memory registered through the API. |
| int64_t external_memory_ = 0; |
| |
| // The limit when to trigger memory pressure from the API. |
| int64_t external_memory_limit_ = kExternalAllocationSoftLimit; |
| |
| // Caches the amount of external memory registered at the last MC. |
| int64_t external_memory_at_last_mark_compact_ = 0; |
| |
| RootsTable roots_; |
| |
| ExternalReferenceTable external_reference_table_; |
| |
| ThreadLocalTop thread_local_top_; |
| |
| // The entry points for all builtins. This corresponds to |
| // Code::InstructionStart() for each Code object in the builtins table below. |
| // The entry table is in IsolateData for easy access through kRootRegister. |
| Address builtin_entry_table_[Builtins::builtin_count] = {}; |
| |
| // The entries in this array are tagged pointers to Code objects. |
| Address builtins_[Builtins::builtin_count] = {}; |
| |
| // For isolate-independent calls on ia32. |
| // TODO(v8:6666): Remove once wasm supports pc-relative jumps to builtins on |
| // ia32 (otherwise the arguments adaptor call runs out of registers). |
| void* virtual_call_target_register_ = nullptr; |
| |
| // Stores the state of the caller for TurboAssembler::CallCFunction so that |
| // the sampling CPU profiler can iterate the stack during such calls. These |
| // are stored on IsolateData so that they can be stored to with only one move |
| // instruction in compiled code. |
| Address fast_c_call_caller_fp_ = kNullAddress; |
| Address fast_c_call_caller_pc_ = kNullAddress; |
| |
| // Ensure the size is 8-byte aligned in order to make alignment of the field |
| // following the IsolateData field predictable. This solves the issue with |
| // C++ compilers for 32-bit platforms which are not consistent at aligning |
| // int64_t fields. |
| // In order to avoid dealing with zero-size arrays the padding size is always |
| // in the range [8, 15). |
| STATIC_ASSERT(kPaddingOffsetEnd + 1 - kPaddingOffset >= 8); |
| char padding_[kPaddingOffsetEnd + 1 - kPaddingOffset]; |
| |
| V8_INLINE static void AssertPredictableLayout(); |
| |
| friend class Isolate; |
| friend class Heap; |
| FRIEND_TEST(HeapTest, ExternalLimitDefault); |
| FRIEND_TEST(HeapTest, ExternalLimitStaysAboveDefaultForExplicitHandling); |
| |
| DISALLOW_COPY_AND_ASSIGN(IsolateData); |
| }; |
| |
| // IsolateData object must have "predictable" layout which does not change when |
| // cross-compiling to another platform. Otherwise there may be compatibility |
| // issues because of different compilers used for snapshot generator and |
| // actual V8 code. |
| void IsolateData::AssertPredictableLayout() { |
| STATIC_ASSERT(std::is_standard_layout<RootsTable>::value); |
| STATIC_ASSERT(std::is_standard_layout<ThreadLocalTop>::value); |
| STATIC_ASSERT(std::is_standard_layout<ExternalReferenceTable>::value); |
| STATIC_ASSERT(std::is_standard_layout<IsolateData>::value); |
| STATIC_ASSERT(offsetof(IsolateData, roots_) == kRootsTableOffset); |
| STATIC_ASSERT(offsetof(IsolateData, external_reference_table_) == |
| kExternalReferenceTableOffset); |
| STATIC_ASSERT(offsetof(IsolateData, thread_local_top_) == |
| kThreadLocalTopOffset); |
| STATIC_ASSERT(offsetof(IsolateData, builtins_) == kBuiltinsTableOffset); |
| STATIC_ASSERT(offsetof(IsolateData, virtual_call_target_register_) == |
| kVirtualCallTargetRegisterOffset); |
| STATIC_ASSERT(offsetof(IsolateData, external_memory_) == |
| kExternalMemoryOffset); |
| STATIC_ASSERT(offsetof(IsolateData, external_memory_limit_) == |
| kExternalMemoryLlimitOffset); |
| STATIC_ASSERT(offsetof(IsolateData, external_memory_at_last_mark_compact_) == |
| kExternalMemoryAtLastMarkCompactOffset); |
| STATIC_ASSERT(offsetof(IsolateData, fast_c_call_caller_fp_) == |
| kFastCCallCallerFPOffset); |
| STATIC_ASSERT(offsetof(IsolateData, fast_c_call_caller_pc_) == |
| kFastCCallCallerPCOffset); |
| STATIC_ASSERT(sizeof(IsolateData) == IsolateData::kSize); |
| } |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_ISOLATE_DATA_H_ |