slots-inl.h 5.53 KB
Newer Older
1 2 3 4 5 6 7 8
// 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_OBJECTS_SLOTS_INL_H_
#define V8_OBJECTS_SLOTS_INL_H_

#include "src/base/atomic-utils.h"
9
#include "src/common/globals.h"
10
#include "src/common/ptr-compr-inl.h"
11
#include "src/objects/compressed-slots.h"
12
#include "src/objects/heap-object.h"
13
#include "src/objects/map.h"
14
#include "src/objects/maybe-object.h"
15
#include "src/objects/objects.h"
16
#include "src/objects/slots.h"
17
#include "src/utils/memcopy.h"
18

19 20 21
namespace v8 {
namespace internal {

22 23 24 25
//
// FullObjectSlot implementation.
//

26
FullObjectSlot::FullObjectSlot(Object* object)
27 28
    : SlotBase(reinterpret_cast<Address>(&object->ptr_)) {}

29
bool FullObjectSlot::contains_value(Address raw_value) const {
30
  return base::AsAtomicPointer::Relaxed_Load(location()) == raw_value;
31 32
}

33 34 35 36
bool FullObjectSlot::contains_map_value(Address raw_value) const {
  return load_map().ptr() == raw_value;
}

37 38
Object FullObjectSlot::operator*() const { return Object(*location()); }

39
Object FullObjectSlot::load(PtrComprCageBase cage_base) const { return **this; }
40

41
void FullObjectSlot::store(Object value) const { *location() = value.ptr(); }
42

43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
void FullObjectSlot::store_map(Map map) const {
#ifdef V8_MAP_PACKING
  *location() = MapWord::Pack(map.ptr());
#else
  store(map);
#endif
}

Map FullObjectSlot::load_map() const {
#ifdef V8_MAP_PACKING
  return Map::unchecked_cast(Object(MapWord::Unpack(*location())));
#else
  return Map::unchecked_cast(Object(*location()));
#endif
}

59 60
Object FullObjectSlot::Acquire_Load() const {
  return Object(base::AsAtomicPointer::Acquire_Load(location()));
61 62
}

63
Object FullObjectSlot::Acquire_Load(PtrComprCageBase cage_base) const {
64 65 66
  return Acquire_Load();
}

67 68
Object FullObjectSlot::Relaxed_Load() const {
  return Object(base::AsAtomicPointer::Relaxed_Load(location()));
69 70
}

71
Object FullObjectSlot::Relaxed_Load(PtrComprCageBase cage_base) const {
72 73 74
  return Relaxed_Load();
}

75
void FullObjectSlot::Relaxed_Store(Object value) const {
76
  base::AsAtomicPointer::Relaxed_Store(location(), value.ptr());
77 78
}

79
void FullObjectSlot::Release_Store(Object value) const {
80
  base::AsAtomicPointer::Release_Store(location(), value.ptr());
81 82
}

83 84 85 86 87 88
Object FullObjectSlot::Relaxed_CompareAndSwap(Object old, Object target) const {
  Address result = base::AsAtomicPointer::Relaxed_CompareAndSwap(
      location(), old.ptr(), target.ptr());
  return Object(result);
}

89
Object FullObjectSlot::Release_CompareAndSwap(Object old, Object target) const {
90
  Address result = base::AsAtomicPointer::Release_CompareAndSwap(
91
      location(), old.ptr(), target.ptr());
92
  return Object(result);
93 94
}

95 96 97 98
//
// FullMaybeObjectSlot implementation.
//

99
MaybeObject FullMaybeObjectSlot::operator*() const {
100 101
  return MaybeObject(*location());
}
102

103
MaybeObject FullMaybeObjectSlot::load(PtrComprCageBase cage_base) const {
104 105 106
  return **this;
}

107
void FullMaybeObjectSlot::store(MaybeObject value) const {
108 109
  *location() = value.ptr();
}
110

111
MaybeObject FullMaybeObjectSlot::Relaxed_Load() const {
112
  return MaybeObject(base::AsAtomicPointer::Relaxed_Load(location()));
113 114
}

115 116
MaybeObject FullMaybeObjectSlot::Relaxed_Load(
    PtrComprCageBase cage_base) const {
117 118 119
  return Relaxed_Load();
}

120
void FullMaybeObjectSlot::Relaxed_Store(MaybeObject value) const {
121
  base::AsAtomicPointer::Relaxed_Store(location(), value->ptr());
122 123
}

124 125
void FullMaybeObjectSlot::Release_CompareAndSwap(MaybeObject old,
                                                 MaybeObject target) const {
126 127
  base::AsAtomicPointer::Release_CompareAndSwap(location(), old.ptr(),
                                                target.ptr());
128 129
}

130 131 132 133
//
// FullHeapObjectSlot implementation.
//

134
HeapObjectReference FullHeapObjectSlot::operator*() const {
135
  return HeapObjectReference(*location());
136
}
137

138
HeapObjectReference FullHeapObjectSlot::load(PtrComprCageBase cage_base) const {
139 140 141
  return **this;
}

142
void FullHeapObjectSlot::store(HeapObjectReference value) const {
143
  *location() = value.ptr();
144 145
}

146
HeapObject FullHeapObjectSlot::ToHeapObject() const {
147 148 149
  TData value = *location();
  DCHECK(HAS_STRONG_HEAP_OBJECT_TAG(value));
  return HeapObject::cast(Object(value));
150 151 152
}

void FullHeapObjectSlot::StoreHeapObject(HeapObject value) const {
153
  *location() = value.ptr();
154 155
}

156 157 158 159
//
// Utils.
//

160 161 162 163 164 165 166 167
// Copies tagged words from |src| to |dst|. The data spans must not overlap.
// |src| and |dst| must be kTaggedSize-aligned.
inline void CopyTagged(Address dst, const Address src, size_t num_tagged) {
  static const size_t kBlockCopyLimit = 16;
  CopyImpl<kBlockCopyLimit>(reinterpret_cast<Tagged_t*>(dst),
                            reinterpret_cast<const Tagged_t*>(src), num_tagged);
}

168
// Sets |counter| number of kTaggedSize-sized values starting at |start| slot.
169
inline void MemsetTagged(Tagged_t* start, Object value, size_t counter) {
170
#ifdef V8_COMPRESS_POINTERS
171
  Tagged_t raw_value = CompressTagged(value.ptr());
172
  MemsetUint32(start, raw_value, counter);
173 174
#else
  Address raw_value = value.ptr();
175
  MemsetPointer(start, raw_value, counter);
176
#endif
177 178
}

179 180 181 182 183 184 185
// Sets |counter| number of kTaggedSize-sized values starting at |start| slot.
template <typename T>
inline void MemsetTagged(SlotBase<T, Tagged_t> start, Object value,
                         size_t counter) {
  MemsetTagged(start.location(), value, counter);
}

186 187
// Sets |counter| number of kSystemPointerSize-sized values starting at |start|
// slot.
188 189
inline void MemsetPointer(FullObjectSlot start, Object value, size_t counter) {
  MemsetPointer(start.location(), value.ptr(), counter);
190 191
}

192 193 194 195
}  // namespace internal
}  // namespace v8

#endif  // V8_OBJECTS_SLOTS_INL_H_