OLD | NEW |
1 // Copyright 2015 the V8 project authors. All rights reserved. | 1 // Copyright 2015 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 #ifndef V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ | 5 #ifndef V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ |
6 #define V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ | 6 #define V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ |
7 | 7 |
8 #include "src/assembler-inl.h" | 8 #include "src/assembler-inl.h" |
9 #include "src/objects-body-descriptors.h" | 9 #include "src/objects-body-descriptors.h" |
10 #include "src/transitions.h" | 10 #include "src/transitions.h" |
(...skipping 61 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
72 offset = end_of_region_offset; | 72 offset = end_of_region_offset; |
73 } | 73 } |
74 } | 74 } |
75 } | 75 } |
76 | 76 |
77 template <typename ObjectVisitor> | 77 template <typename ObjectVisitor> |
78 DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(HeapObject* obj, | 78 DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(HeapObject* obj, |
79 int start_offset, | 79 int start_offset, |
80 int end_offset, | 80 int end_offset, |
81 ObjectVisitor* v) { | 81 ObjectVisitor* v) { |
82 v->VisitPointers(HeapObject::RawField(obj, start_offset), | 82 v->VisitPointers(obj, HeapObject::RawField(obj, start_offset), |
83 HeapObject::RawField(obj, end_offset)); | 83 HeapObject::RawField(obj, end_offset)); |
84 } | 84 } |
85 | 85 |
86 template <typename StaticVisitor> | 86 template <typename StaticVisitor> |
87 DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(Heap* heap, | 87 DISABLE_CFI_PERF void BodyDescriptorBase::IteratePointers(Heap* heap, |
88 HeapObject* obj, | 88 HeapObject* obj, |
89 int start_offset, | 89 int start_offset, |
90 int end_offset) { | 90 int end_offset) { |
91 StaticVisitor::VisitPointers(heap, obj, | 91 StaticVisitor::VisitPointers(heap, obj, |
92 HeapObject::RawField(obj, start_offset), | 92 HeapObject::RawField(obj, start_offset), |
93 HeapObject::RawField(obj, end_offset)); | 93 HeapObject::RawField(obj, end_offset)); |
94 } | 94 } |
95 | 95 |
96 template <typename ObjectVisitor> | 96 template <typename ObjectVisitor> |
97 void BodyDescriptorBase::IteratePointer(HeapObject* obj, int offset, | 97 void BodyDescriptorBase::IteratePointer(HeapObject* obj, int offset, |
98 ObjectVisitor* v) { | 98 ObjectVisitor* v) { |
99 v->VisitPointer(HeapObject::RawField(obj, offset)); | 99 v->VisitPointer(obj, HeapObject::RawField(obj, offset)); |
100 } | 100 } |
101 | 101 |
102 template <typename StaticVisitor> | 102 template <typename StaticVisitor> |
103 void BodyDescriptorBase::IteratePointer(Heap* heap, HeapObject* obj, | 103 void BodyDescriptorBase::IteratePointer(Heap* heap, HeapObject* obj, |
104 int offset) { | 104 int offset) { |
105 StaticVisitor::VisitPointer(heap, obj, HeapObject::RawField(obj, offset)); | 105 StaticVisitor::VisitPointer(heap, obj, HeapObject::RawField(obj, offset)); |
106 } | 106 } |
107 | 107 |
108 class JSObject::BodyDescriptor final : public BodyDescriptorBase { | 108 class JSObject::BodyDescriptor final : public BodyDescriptorBase { |
109 public: | 109 public: |
(...skipping 58 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
168 if (offset < kSize) return true; | 168 if (offset < kSize) return true; |
169 return IsValidSlotImpl(obj, offset); | 169 return IsValidSlotImpl(obj, offset); |
170 } | 170 } |
171 | 171 |
172 template <typename ObjectVisitor> | 172 template <typename ObjectVisitor> |
173 static inline void IterateBody(HeapObject* obj, int object_size, | 173 static inline void IterateBody(HeapObject* obj, int object_size, |
174 ObjectVisitor* v) { | 174 ObjectVisitor* v) { |
175 IteratePointers(obj, kPropertiesOffset, kNonWeakFieldsEndOffset, v); | 175 IteratePointers(obj, kPropertiesOffset, kNonWeakFieldsEndOffset, v); |
176 | 176 |
177 if (body_visiting_policy & kVisitCodeEntry) { | 177 if (body_visiting_policy & kVisitCodeEntry) { |
178 v->VisitCodeEntry(obj->address() + kCodeEntryOffset); | 178 v->VisitCodeEntry(JSFunction::cast(obj), |
| 179 obj->address() + kCodeEntryOffset); |
179 } | 180 } |
180 | 181 |
181 if (body_visiting_policy & kVisitNextFunction) { | 182 if (body_visiting_policy & kVisitNextFunction) { |
182 IteratePointers(obj, kNextFunctionLinkOffset, kSize, v); | 183 IteratePointers(obj, kNextFunctionLinkOffset, kSize, v); |
183 } | 184 } |
184 IterateBodyImpl(obj, kSize, object_size, v); | 185 IterateBodyImpl(obj, kSize, object_size, v); |
185 } | 186 } |
186 | 187 |
187 template <typename StaticVisitor> | 188 template <typename StaticVisitor> |
188 static inline void IterateBody(HeapObject* obj, int object_size) { | 189 static inline void IterateBody(HeapObject* obj, int object_size) { |
(...skipping 138 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 } | 328 } |
328 }; | 329 }; |
329 | 330 |
330 class Foreign::BodyDescriptor final : public BodyDescriptorBase { | 331 class Foreign::BodyDescriptor final : public BodyDescriptorBase { |
331 public: | 332 public: |
332 static bool IsValidSlot(HeapObject* obj, int offset) { return false; } | 333 static bool IsValidSlot(HeapObject* obj, int offset) { return false; } |
333 | 334 |
334 template <typename ObjectVisitor> | 335 template <typename ObjectVisitor> |
335 static inline void IterateBody(HeapObject* obj, int object_size, | 336 static inline void IterateBody(HeapObject* obj, int object_size, |
336 ObjectVisitor* v) { | 337 ObjectVisitor* v) { |
337 v->VisitExternalReference(reinterpret_cast<Address*>( | 338 v->VisitExternalReference(Foreign::cast(obj), |
338 HeapObject::RawField(obj, kForeignAddressOffset))); | 339 reinterpret_cast<Address*>(HeapObject::RawField( |
| 340 obj, kForeignAddressOffset))); |
339 } | 341 } |
340 | 342 |
341 template <typename StaticVisitor> | 343 template <typename StaticVisitor> |
342 static inline void IterateBody(HeapObject* obj, int object_size) { | 344 static inline void IterateBody(HeapObject* obj, int object_size) { |
343 StaticVisitor::VisitExternalReference(reinterpret_cast<Address*>( | 345 StaticVisitor::VisitExternalReference(reinterpret_cast<Address*>( |
344 HeapObject::RawField(obj, kForeignAddressOffset))); | 346 HeapObject::RawField(obj, kForeignAddressOffset))); |
345 } | 347 } |
346 | 348 |
347 static inline int SizeOf(Map* map, HeapObject* object) { return kSize; } | 349 static inline int SizeOf(Map* map, HeapObject* object) { return kSize; } |
348 }; | 350 }; |
(...skipping 52 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
401 int mode_mask = RelocInfo::kCodeTargetMask | | 403 int mode_mask = RelocInfo::kCodeTargetMask | |
402 RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) | | 404 RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) | |
403 RelocInfo::ModeMask(RelocInfo::CELL) | | 405 RelocInfo::ModeMask(RelocInfo::CELL) | |
404 RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) | | 406 RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) | |
405 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) | | 407 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) | |
406 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) | | 408 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) | |
407 RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) | | 409 RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) | |
408 RelocInfo::kDebugBreakSlotMask; | 410 RelocInfo::kDebugBreakSlotMask; |
409 | 411 |
410 IteratePointers(obj, kRelocationInfoOffset, kNextCodeLinkOffset, v); | 412 IteratePointers(obj, kRelocationInfoOffset, kNextCodeLinkOffset, v); |
411 v->VisitNextCodeLink(HeapObject::RawField(obj, kNextCodeLinkOffset)); | 413 v->VisitNextCodeLink(Code::cast(obj), |
| 414 HeapObject::RawField(obj, kNextCodeLinkOffset)); |
412 | 415 |
413 RelocIterator it(reinterpret_cast<Code*>(obj), mode_mask); | 416 RelocIterator it(Code::cast(obj), mode_mask); |
414 Isolate* isolate = obj->GetIsolate(); | 417 Isolate* isolate = obj->GetIsolate(); |
415 for (; !it.done(); it.next()) { | 418 for (; !it.done(); it.next()) { |
416 it.rinfo()->Visit(isolate, v); | 419 it.rinfo()->Visit(isolate, v); |
417 } | 420 } |
418 } | 421 } |
419 | 422 |
420 template <typename ObjectVisitor> | 423 template <typename ObjectVisitor> |
421 static inline void IterateBody(HeapObject* obj, int object_size, | 424 static inline void IterateBody(HeapObject* obj, int object_size, |
422 ObjectVisitor* v) { | 425 ObjectVisitor* v) { |
423 IterateBody(obj, v); | 426 IterateBody(obj, v); |
424 } | 427 } |
425 | 428 |
426 template <typename StaticVisitor> | 429 template <typename StaticVisitor> |
427 static inline void IterateBody(HeapObject* obj) { | 430 static inline void IterateBody(HeapObject* obj) { |
428 int mode_mask = RelocInfo::kCodeTargetMask | | 431 int mode_mask = RelocInfo::kCodeTargetMask | |
429 RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) | | 432 RelocInfo::ModeMask(RelocInfo::EMBEDDED_OBJECT) | |
430 RelocInfo::ModeMask(RelocInfo::CELL) | | 433 RelocInfo::ModeMask(RelocInfo::CELL) | |
431 RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) | | 434 RelocInfo::ModeMask(RelocInfo::EXTERNAL_REFERENCE) | |
432 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) | | 435 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE) | |
433 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) | | 436 RelocInfo::ModeMask(RelocInfo::INTERNAL_REFERENCE_ENCODED) | |
434 RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) | | 437 RelocInfo::ModeMask(RelocInfo::RUNTIME_ENTRY) | |
435 RelocInfo::kDebugBreakSlotMask; | 438 RelocInfo::kDebugBreakSlotMask; |
436 | 439 |
437 Heap* heap = obj->GetHeap(); | 440 Heap* heap = obj->GetHeap(); |
438 IteratePointers<StaticVisitor>(heap, obj, kRelocationInfoOffset, | 441 IteratePointers<StaticVisitor>(heap, obj, kRelocationInfoOffset, |
439 kNextCodeLinkOffset); | 442 kNextCodeLinkOffset); |
440 StaticVisitor::VisitNextCodeLink( | 443 StaticVisitor::VisitNextCodeLink( |
441 heap, HeapObject::RawField(obj, kNextCodeLinkOffset)); | 444 heap, HeapObject::RawField(obj, kNextCodeLinkOffset)); |
442 | 445 |
443 RelocIterator it(reinterpret_cast<Code*>(obj), mode_mask); | 446 RelocIterator it(Code::cast(obj), mode_mask); |
444 for (; !it.done(); it.next()) { | 447 for (; !it.done(); it.next()) { |
445 it.rinfo()->template Visit<StaticVisitor>(heap); | 448 it.rinfo()->template Visit<StaticVisitor>(heap); |
446 } | 449 } |
447 } | 450 } |
448 | 451 |
449 template <typename StaticVisitor> | 452 template <typename StaticVisitor> |
450 static inline void IterateBody(HeapObject* obj, int object_size) { | 453 static inline void IterateBody(HeapObject* obj, int object_size) { |
451 IterateBody<StaticVisitor>(obj); | 454 IterateBody<StaticVisitor>(obj); |
452 } | 455 } |
453 | 456 |
(...skipping 185 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
639 | 642 |
640 template <typename ObjectVisitor> | 643 template <typename ObjectVisitor> |
641 void HeapObject::IterateBodyFast(InstanceType type, int object_size, | 644 void HeapObject::IterateBodyFast(InstanceType type, int object_size, |
642 ObjectVisitor* v) { | 645 ObjectVisitor* v) { |
643 BodyDescriptorApply<CallIterateBody, void>(type, this, object_size, v); | 646 BodyDescriptorApply<CallIterateBody, void>(type, this, object_size, v); |
644 } | 647 } |
645 } // namespace internal | 648 } // namespace internal |
646 } // namespace v8 | 649 } // namespace v8 |
647 | 650 |
648 #endif // V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ | 651 #endif // V8_OBJECTS_BODY_DESCRIPTORS_INL_H_ |
OLD | NEW |