OLD | NEW |
1 // Copyright 2016 the V8 project authors. All rights reserved. | 1 // Copyright 2016 the V8 project authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 // Note 1: Any file that includes this one should include object-macros-undef.h | 5 // Note 1: Any file that includes this one should include object-macros-undef.h |
6 // at the bottom. | 6 // at the bottom. |
7 | 7 |
8 // Note 2: This file is deliberately missing the include guards (the undeffing | 8 // Note 2: This file is deliberately missing the include guards (the undeffing |
9 // approach wouldn't work otherwise). | 9 // approach wouldn't work otherwise). |
10 | 10 |
(...skipping 17 matching lines...) Expand all Loading... |
28 #define CAST_ACCESSOR(type) \ | 28 #define CAST_ACCESSOR(type) \ |
29 type* type::cast(Object* object) { \ | 29 type* type::cast(Object* object) { \ |
30 SLOW_DCHECK(object->Is##type()); \ | 30 SLOW_DCHECK(object->Is##type()); \ |
31 return reinterpret_cast<type*>(object); \ | 31 return reinterpret_cast<type*>(object); \ |
32 } \ | 32 } \ |
33 const type* type::cast(const Object* object) { \ | 33 const type* type::cast(const Object* object) { \ |
34 SLOW_DCHECK(object->Is##type()); \ | 34 SLOW_DCHECK(object->Is##type()); \ |
35 return reinterpret_cast<const type*>(object); \ | 35 return reinterpret_cast<const type*>(object); \ |
36 } | 36 } |
37 | 37 |
| 38 #define INT_ACCESSORS(holder, name, offset) \ |
| 39 int holder::name() const { return READ_INT_FIELD(this, offset); } \ |
| 40 void holder::set_##name(int value) { WRITE_INT_FIELD(this, offset, value); } |
| 41 |
| 42 #define ACCESSORS_CHECKED2(holder, name, type, offset, get_condition, \ |
| 43 set_condition) \ |
| 44 type* holder::name() const { \ |
| 45 DCHECK(get_condition); \ |
| 46 return type::cast(READ_FIELD(this, offset)); \ |
| 47 } \ |
| 48 void holder::set_##name(type* value, WriteBarrierMode mode) { \ |
| 49 DCHECK(set_condition); \ |
| 50 WRITE_FIELD(this, offset, value); \ |
| 51 CONDITIONAL_WRITE_BARRIER(GetHeap(), this, offset, value, mode); \ |
| 52 } |
| 53 #define ACCESSORS_CHECKED(holder, name, type, offset, condition) \ |
| 54 ACCESSORS_CHECKED2(holder, name, type, offset, condition, condition) |
| 55 |
| 56 #define ACCESSORS(holder, name, type, offset) \ |
| 57 ACCESSORS_CHECKED(holder, name, type, offset, true) |
| 58 |
| 59 // Getter that returns a Smi as an int and writes an int as a Smi. |
| 60 #define SMI_ACCESSORS_CHECKED(holder, name, offset, condition) \ |
| 61 int holder::name() const { \ |
| 62 DCHECK(condition); \ |
| 63 Object* value = READ_FIELD(this, offset); \ |
| 64 return Smi::cast(value)->value(); \ |
| 65 } \ |
| 66 void holder::set_##name(int value) { \ |
| 67 DCHECK(condition); \ |
| 68 WRITE_FIELD(this, offset, Smi::FromInt(value)); \ |
| 69 } |
| 70 |
| 71 #define SMI_ACCESSORS(holder, name, offset) \ |
| 72 SMI_ACCESSORS_CHECKED(holder, name, offset, true) |
| 73 |
| 74 #define SYNCHRONIZED_SMI_ACCESSORS(holder, name, offset) \ |
| 75 int holder::synchronized_##name() const { \ |
| 76 Object* value = ACQUIRE_READ_FIELD(this, offset); \ |
| 77 return Smi::cast(value)->value(); \ |
| 78 } \ |
| 79 void holder::synchronized_set_##name(int value) { \ |
| 80 RELEASE_WRITE_FIELD(this, offset, Smi::FromInt(value)); \ |
| 81 } |
| 82 |
| 83 #define NOBARRIER_SMI_ACCESSORS(holder, name, offset) \ |
| 84 int holder::nobarrier_##name() const { \ |
| 85 Object* value = NOBARRIER_READ_FIELD(this, offset); \ |
| 86 return Smi::cast(value)->value(); \ |
| 87 } \ |
| 88 void holder::nobarrier_set_##name(int value) { \ |
| 89 NOBARRIER_WRITE_FIELD(this, offset, Smi::FromInt(value)); \ |
| 90 } |
| 91 |
| 92 #define BOOL_GETTER(holder, field, name, offset) \ |
| 93 bool holder::name() const { return BooleanBit::get(field(), offset); } |
| 94 |
| 95 #define BOOL_ACCESSORS(holder, field, name, offset) \ |
| 96 bool holder::name() const { return BooleanBit::get(field(), offset); } \ |
| 97 void holder::set_##name(bool value) { \ |
| 98 set_##field(BooleanBit::set(field(), offset, value)); \ |
| 99 } |
| 100 |
| 101 #define TYPE_CHECKER(type, instancetype) \ |
| 102 bool HeapObject::Is##type() const { \ |
| 103 return map()->instance_type() == instancetype; \ |
| 104 } |
| 105 |
| 106 #define FIELD_ADDR(p, offset) \ |
| 107 (reinterpret_cast<byte*>(p) + offset - kHeapObjectTag) |
| 108 |
| 109 #define FIELD_ADDR_CONST(p, offset) \ |
| 110 (reinterpret_cast<const byte*>(p) + offset - kHeapObjectTag) |
| 111 |
| 112 #define READ_FIELD(p, offset) \ |
| 113 (*reinterpret_cast<Object* const*>(FIELD_ADDR_CONST(p, offset))) |
| 114 |
| 115 #define ACQUIRE_READ_FIELD(p, offset) \ |
| 116 reinterpret_cast<Object*>(base::Acquire_Load( \ |
| 117 reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset)))) |
| 118 |
| 119 #define NOBARRIER_READ_FIELD(p, offset) \ |
| 120 reinterpret_cast<Object*>(base::NoBarrier_Load( \ |
| 121 reinterpret_cast<const base::AtomicWord*>(FIELD_ADDR_CONST(p, offset)))) |
| 122 |
| 123 #ifdef V8_CONCURRENT_MARKING |
| 124 #define WRITE_FIELD(p, offset, value) \ |
| 125 base::NoBarrier_Store( \ |
| 126 reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \ |
| 127 reinterpret_cast<base::AtomicWord>(value)); |
| 128 #else |
| 129 #define WRITE_FIELD(p, offset, value) \ |
| 130 (*reinterpret_cast<Object**>(FIELD_ADDR(p, offset)) = value) |
| 131 #endif |
| 132 |
| 133 #define RELEASE_WRITE_FIELD(p, offset, value) \ |
| 134 base::Release_Store( \ |
| 135 reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \ |
| 136 reinterpret_cast<base::AtomicWord>(value)); |
| 137 |
| 138 #define NOBARRIER_WRITE_FIELD(p, offset, value) \ |
| 139 base::NoBarrier_Store( \ |
| 140 reinterpret_cast<base::AtomicWord*>(FIELD_ADDR(p, offset)), \ |
| 141 reinterpret_cast<base::AtomicWord>(value)); |
| 142 |
| 143 #define WRITE_BARRIER(heap, object, offset, value) \ |
| 144 heap->incremental_marking()->RecordWrite( \ |
| 145 object, HeapObject::RawField(object, offset), value); \ |
| 146 heap->RecordWrite(object, offset, value); |
| 147 |
| 148 #define CONDITIONAL_WRITE_BARRIER(heap, object, offset, value, mode) \ |
| 149 if (mode != SKIP_WRITE_BARRIER) { \ |
| 150 if (mode == UPDATE_WRITE_BARRIER) { \ |
| 151 heap->incremental_marking()->RecordWrite( \ |
| 152 object, HeapObject::RawField(object, offset), value); \ |
| 153 } \ |
| 154 heap->RecordWrite(object, offset, value); \ |
| 155 } |
| 156 |
| 157 #define READ_DOUBLE_FIELD(p, offset) \ |
| 158 ReadDoubleValue(FIELD_ADDR_CONST(p, offset)) |
| 159 |
| 160 #define WRITE_DOUBLE_FIELD(p, offset, value) \ |
| 161 WriteDoubleValue(FIELD_ADDR(p, offset), value) |
| 162 |
| 163 #define READ_INT_FIELD(p, offset) \ |
| 164 (*reinterpret_cast<const int*>(FIELD_ADDR_CONST(p, offset))) |
| 165 |
| 166 #define WRITE_INT_FIELD(p, offset, value) \ |
| 167 (*reinterpret_cast<int*>(FIELD_ADDR(p, offset)) = value) |
| 168 |
| 169 #define READ_INTPTR_FIELD(p, offset) \ |
| 170 (*reinterpret_cast<const intptr_t*>(FIELD_ADDR_CONST(p, offset))) |
| 171 |
| 172 #define WRITE_INTPTR_FIELD(p, offset, value) \ |
| 173 (*reinterpret_cast<intptr_t*>(FIELD_ADDR(p, offset)) = value) |
| 174 |
| 175 #define READ_UINT8_FIELD(p, offset) \ |
| 176 (*reinterpret_cast<const uint8_t*>(FIELD_ADDR_CONST(p, offset))) |
| 177 |
| 178 #define WRITE_UINT8_FIELD(p, offset, value) \ |
| 179 (*reinterpret_cast<uint8_t*>(FIELD_ADDR(p, offset)) = value) |
| 180 |
| 181 #define READ_INT8_FIELD(p, offset) \ |
| 182 (*reinterpret_cast<const int8_t*>(FIELD_ADDR_CONST(p, offset))) |
| 183 |
| 184 #define WRITE_INT8_FIELD(p, offset, value) \ |
| 185 (*reinterpret_cast<int8_t*>(FIELD_ADDR(p, offset)) = value) |
| 186 |
| 187 #define READ_UINT16_FIELD(p, offset) \ |
| 188 (*reinterpret_cast<const uint16_t*>(FIELD_ADDR_CONST(p, offset))) |
| 189 |
| 190 #define WRITE_UINT16_FIELD(p, offset, value) \ |
| 191 (*reinterpret_cast<uint16_t*>(FIELD_ADDR(p, offset)) = value) |
| 192 |
| 193 #define READ_INT16_FIELD(p, offset) \ |
| 194 (*reinterpret_cast<const int16_t*>(FIELD_ADDR_CONST(p, offset))) |
| 195 |
| 196 #define WRITE_INT16_FIELD(p, offset, value) \ |
| 197 (*reinterpret_cast<int16_t*>(FIELD_ADDR(p, offset)) = value) |
| 198 |
| 199 #define READ_UINT32_FIELD(p, offset) \ |
| 200 (*reinterpret_cast<const uint32_t*>(FIELD_ADDR_CONST(p, offset))) |
| 201 |
| 202 #define WRITE_UINT32_FIELD(p, offset, value) \ |
| 203 (*reinterpret_cast<uint32_t*>(FIELD_ADDR(p, offset)) = value) |
| 204 |
| 205 #define READ_INT32_FIELD(p, offset) \ |
| 206 (*reinterpret_cast<const int32_t*>(FIELD_ADDR_CONST(p, offset))) |
| 207 |
| 208 #define WRITE_INT32_FIELD(p, offset, value) \ |
| 209 (*reinterpret_cast<int32_t*>(FIELD_ADDR(p, offset)) = value) |
| 210 |
| 211 #define READ_FLOAT_FIELD(p, offset) \ |
| 212 (*reinterpret_cast<const float*>(FIELD_ADDR_CONST(p, offset))) |
| 213 |
| 214 #define WRITE_FLOAT_FIELD(p, offset, value) \ |
| 215 (*reinterpret_cast<float*>(FIELD_ADDR(p, offset)) = value) |
| 216 |
| 217 #define READ_UINT64_FIELD(p, offset) \ |
| 218 (*reinterpret_cast<const uint64_t*>(FIELD_ADDR_CONST(p, offset))) |
| 219 |
| 220 #define WRITE_UINT64_FIELD(p, offset, value) \ |
| 221 (*reinterpret_cast<uint64_t*>(FIELD_ADDR(p, offset)) = value) |
| 222 |
| 223 #define READ_INT64_FIELD(p, offset) \ |
| 224 (*reinterpret_cast<const int64_t*>(FIELD_ADDR_CONST(p, offset))) |
| 225 |
| 226 #define WRITE_INT64_FIELD(p, offset, value) \ |
| 227 (*reinterpret_cast<int64_t*>(FIELD_ADDR(p, offset)) = value) |
| 228 |
| 229 #define READ_BYTE_FIELD(p, offset) \ |
| 230 (*reinterpret_cast<const byte*>(FIELD_ADDR_CONST(p, offset))) |
| 231 |
| 232 #define NOBARRIER_READ_BYTE_FIELD(p, offset) \ |
| 233 static_cast<byte>(base::NoBarrier_Load( \ |
| 234 reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)))) |
| 235 |
| 236 #define WRITE_BYTE_FIELD(p, offset, value) \ |
| 237 (*reinterpret_cast<byte*>(FIELD_ADDR(p, offset)) = value) |
| 238 |
| 239 #define NOBARRIER_WRITE_BYTE_FIELD(p, offset, value) \ |
| 240 base::NoBarrier_Store( \ |
| 241 reinterpret_cast<base::Atomic8*>(FIELD_ADDR(p, offset)), \ |
| 242 static_cast<base::Atomic8>(value)); |
| 243 |
38 #ifdef VERIFY_HEAP | 244 #ifdef VERIFY_HEAP |
39 #define DECLARE_VERIFIER(Name) void Name##Verify(); | 245 #define DECLARE_VERIFIER(Name) void Name##Verify(); |
40 #else | 246 #else |
41 #define DECLARE_VERIFIER(Name) | 247 #define DECLARE_VERIFIER(Name) |
42 #endif | 248 #endif |
OLD | NEW |