Line data    Source code

       1             : // Copyright 2018 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_OBJECTS_EMBEDDER_DATA_SLOT_INL_H_
       6             : #define V8_OBJECTS_EMBEDDER_DATA_SLOT_INL_H_
       7             : 
       8             : #include "src/objects/embedder-data-slot.h"
       9             : 
      10             : #include "src/heap/heap-write-barrier-inl.h"
      11             : #include "src/objects-inl.h"
      12             : #include "src/objects/embedder-data-array.h"
      13             : #include "src/objects/js-objects-inl.h"
      14             : 
      15             : // Has to be the last include (doesn't have include guards):
      16             : #include "src/objects/object-macros.h"
      17             : 
      18             : namespace v8 {
      19             : namespace internal {
      20             : 
      21             : EmbedderDataSlot::EmbedderDataSlot(EmbedderDataArray array, int entry_index)
      22      112099 :     : SlotBase(FIELD_ADDR(array,
      23      112099 :                           EmbedderDataArray::OffsetOfElementAt(entry_index))) {}
      24             : 
      25             : EmbedderDataSlot::EmbedderDataSlot(JSObject object, int embedder_field_index)
      26      939523 :     : SlotBase(FIELD_ADDR(
      27      939526 :           object, object->GetEmbedderFieldOffset(embedder_field_index))) {}
      28             : 
      29             : Object EmbedderDataSlot::load_tagged() const {
      30      937792 :   return ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Load();
      31             : }
      32             : 
      33             : void EmbedderDataSlot::store_smi(Smi value) {
      34             :   ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Store(value);
      35             : #ifdef V8_COMPRESS_POINTERS
      36             :   ObjectSlot(address() + kRawPayloadOffset).Relaxed_Store(Smi::kZero);
      37             : #endif
      38             : }
      39             : 
      40             : // static
      41             : void EmbedderDataSlot::store_tagged(EmbedderDataArray array, int entry_index,
      42             :                                     Object value) {
      43          60 :   int slot_offset = EmbedderDataArray::OffsetOfElementAt(entry_index);
      44          60 :   ObjectSlot(FIELD_ADDR(array, slot_offset + kTaggedPayloadOffset))
      45          60 :       .Relaxed_Store(value);
      46          60 :   WRITE_BARRIER(array, slot_offset, value);
      47             : #ifdef V8_COMPRESS_POINTERS
      48             :   ObjectSlot(FIELD_ADDR(array, slot_offset + kRawPayloadOffset))
      49             :       .Relaxed_Store(Smi::kZero);
      50             : #endif
      51             : }
      52             : 
      53             : // static
      54             : void EmbedderDataSlot::store_tagged(JSObject object, int embedder_field_index,
      55             :                                     Object value) {
      56      824723 :   int slot_offset = object->GetEmbedderFieldOffset(embedder_field_index);
      57      824723 :   ObjectSlot(FIELD_ADDR(object, slot_offset + kTaggedPayloadOffset))
      58      824723 :       .Relaxed_Store(value);
      59      824724 :   WRITE_BARRIER(object, slot_offset, value);
      60             : #ifdef V8_COMPRESS_POINTERS
      61             :   ObjectSlot(FIELD_ADDR(object, slot_offset + kRawPayloadOffset))
      62             :       .Relaxed_Store(Smi::kZero);
      63             : #endif
      64             : }
      65             : 
      66             : bool EmbedderDataSlot::ToAlignedPointer(void** out_pointer) const {
      67             :   Object tagged_value =
      68         234 :       ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Load();
      69         468 :   if (!tagged_value->IsSmi()) return false;
      70             : #ifdef V8_COMPRESS_POINTERS
      71             :   STATIC_ASSERT(kSmiShiftSize == 0);
      72             :   STATIC_ASSERT(SmiValuesAre31Bits());
      73             :   Address value_lo = static_cast<uint32_t>(tagged_value->ptr());
      74             :   STATIC_ASSERT(kTaggedSize == kSystemPointerSize);
      75             :   Address value_hi =
      76             :       FullObjectSlot(address() + kRawPayloadOffset).Relaxed_Load()->ptr();
      77             :   Address value = value_lo | (value_hi << 32);
      78             :   *out_pointer = reinterpret_cast<void*>(value);
      79             : #else
      80         214 :   *out_pointer = reinterpret_cast<void*>(tagged_value->ptr());
      81             : #endif
      82             :   return true;
      83             : }
      84             : 
      85             : bool EmbedderDataSlot::store_aligned_pointer(void* ptr) {
      86      113569 :   Address value = reinterpret_cast<Address>(ptr);
      87      113569 :   if (!HAS_SMI_TAG(value)) return false;
      88             : #ifdef V8_COMPRESS_POINTERS
      89             :   STATIC_ASSERT(kSmiShiftSize == 0);
      90             :   STATIC_ASSERT(SmiValuesAre31Bits());
      91             :   // Sign-extend lower 32-bits in order to form a proper Smi value.
      92             :   STATIC_ASSERT(kTaggedSize == kSystemPointerSize);
      93             :   Address lo = static_cast<intptr_t>(static_cast<int32_t>(value));
      94             :   ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Store(Smi(lo));
      95             :   Address hi = value >> 32;
      96             :   ObjectSlot(address() + kRawPayloadOffset).Relaxed_Store(Object(hi));
      97             : #else
      98      113569 :   ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Store(Smi(value));
      99             : #endif
     100             :   return true;
     101             : }
     102             : 
     103             : EmbedderDataSlot::RawData EmbedderDataSlot::load_raw(
     104             :     const DisallowHeapAllocation& no_gc) const {
     105             :   STATIC_ASSERT(kTaggedSize == kSystemPointerSize);
     106             :   return RawData{
     107         360 :       ObjectSlot(address() + kTaggedPayloadOffset).Relaxed_Load()->ptr(),
     108             : #ifdef V8_COMPRESS_POINTERS
     109             :       FullObjectSlot(address() + kRawPayloadOffset).Relaxed_Load()->ptr()
     110             : #endif
     111             :   };
     112             : }
     113             : 
     114             : void EmbedderDataSlot::store_raw(const EmbedderDataSlot::RawData& data,
     115             :                                  const DisallowHeapAllocation& no_gc) {
     116             :   ObjectSlot(address() + kTaggedPayloadOffset)
     117          30 :       .Relaxed_Store(Object(data.data_[0]));
     118             : #ifdef V8_COMPRESS_POINTERS
     119             :   ObjectSlot(address() + kRawPayloadOffset)
     120             :       .Relaxed_Store(Object(data.data_[1]));
     121             : #endif
     122             : }
     123             : 
     124             : }  // namespace internal
     125             : }  // namespace v8
     126             : 
     127             : #include "src/objects/object-macros-undef.h"
     128             : 
     129             : #endif  // V8_OBJECTS_EMBEDDER_DATA_SLOT_INL_H_