objects-body-descriptors.h 6.87 KB
Newer Older
1 2 3 4 5 6 7 8
// Copyright 2015 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_BODY_DESCRIPTORS_H_
#define V8_OBJECTS_BODY_DESCRIPTORS_H_

#include "src/objects.h"
9
#include "src/objects/map.h"
10 11 12 13 14 15 16 17 18 19 20 21

namespace v8 {
namespace internal {

// This is the base class for object's body descriptors.
//
// Each BodyDescriptor subclass must provide the following methods:
//
// 1) Returns true if the object contains a tagged value at given offset.
//    It is used for invalid slots filtering. If the offset points outside
//    of the object or to the map word, the result is UNDEFINED (!!!).
//
22
//   static bool IsValidSlot(Map map, HeapObject obj, int offset);
23 24 25 26 27
//
//
// 2) Iterate object's body using stateful object visitor.
//
//   template <typename ObjectVisitor>
28
//   static inline void IterateBody(Map map, HeapObject obj, int object_size,
29
//                                  ObjectVisitor* v);
30
class BodyDescriptorBase {
31 32
 public:
  template <typename ObjectVisitor>
33
  static inline void IteratePointers(HeapObject obj, int start_offset,
34 35 36
                                     int end_offset, ObjectVisitor* v);

  template <typename ObjectVisitor>
37
  static inline void IteratePointer(HeapObject obj, int offset,
38 39
                                    ObjectVisitor* v);

40
  template <typename ObjectVisitor>
41 42
  static inline void IterateCustomWeakPointers(HeapObject obj, int start_offset,
                                               int end_offset,
43 44 45
                                               ObjectVisitor* v);

  template <typename ObjectVisitor>
46
  static inline void IterateCustomWeakPointer(HeapObject obj, int offset,
47 48
                                              ObjectVisitor* v);

49 50 51 52
  template <typename ObjectVisitor>
  static inline void IterateEphemeron(HeapObject obj, int index, int key_offset,
                                      int value_offset, ObjectVisitor* v);

53
  template <typename ObjectVisitor>
54
  static inline void IterateMaybeWeakPointers(HeapObject obj, int start_offset,
55 56
                                              int end_offset, ObjectVisitor* v);

57
  template <typename ObjectVisitor>
58
  static inline void IterateMaybeWeakPointer(HeapObject obj, int offset,
59 60
                                             ObjectVisitor* v);

61
 protected:
62
  // Returns true for all header and embedder fields.
63
  static inline bool IsValidJSObjectSlotImpl(Map map, HeapObject obj,
64 65 66
                                             int offset);

  // Returns true for all header and embedder fields.
67
  static inline bool IsValidEmbedderJSObjectSlotImpl(Map map, HeapObject obj,
68
                                                     int offset);
69

70
  // Treats all header and embedder fields in the range as tagged.
71
  template <typename ObjectVisitor>
72
  static inline void IterateJSObjectBodyImpl(Map map, HeapObject obj,
73 74
                                             int start_offset, int end_offset,
                                             ObjectVisitor* v);
75 76 77 78 79 80 81 82 83 84 85 86 87
};


// This class describes a body of an object of a fixed size
// in which all pointer fields are located in the [start_offset, end_offset)
// interval.
template <int start_offset, int end_offset, int size>
class FixedBodyDescriptor final : public BodyDescriptorBase {
 public:
  static const int kStartOffset = start_offset;
  static const int kEndOffset = end_offset;
  static const int kSize = size;

88
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
89 90 91 92
    return offset >= kStartOffset && offset < kEndOffset;
  }

  template <typename ObjectVisitor>
93
  static inline void IterateBody(Map map, HeapObject obj, ObjectVisitor* v) {
94
    IteratePointers(obj, start_offset, end_offset, v);
95 96 97
  }

  template <typename ObjectVisitor>
98
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
99
                                 ObjectVisitor* v) {
100
    IterateBody(map, obj, v);
101 102
  }

103
  static inline int SizeOf(Map map, HeapObject object) { return kSize; }
104 105 106 107 108 109 110 111 112 113 114
};


// This class describes a body of an object of a variable size
// in which all pointer fields are located in the [start_offset, object_size)
// interval.
template <int start_offset>
class FlexibleBodyDescriptor final : public BodyDescriptorBase {
 public:
  static const int kStartOffset = start_offset;

115
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
116
    return (offset >= kStartOffset);
117 118 119
  }

  template <typename ObjectVisitor>
120
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
121
                                 ObjectVisitor* v) {
122
    IteratePointers(obj, start_offset, object_size, v);
123 124
  }

125
  static inline int SizeOf(Map map, HeapObject object);
126 127
};

128

129 130
typedef FlexibleBodyDescriptor<HeapObject::kHeaderSize> StructBodyDescriptor;

131 132 133 134 135
template <int start_offset>
class FlexibleWeakBodyDescriptor final : public BodyDescriptorBase {
 public:
  static const int kStartOffset = start_offset;

136
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
137 138 139 140
    return (offset >= kStartOffset);
  }

  template <typename ObjectVisitor>
141
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
142 143 144 145
                                 ObjectVisitor* v) {
    IterateMaybeWeakPointers(obj, start_offset, object_size, v);
  }

146
  static inline int SizeOf(Map map, HeapObject object);
147 148
};

149 150 151 152 153 154 155 156 157 158 159 160 161
// This class describes a body of an object which has a parent class that also
// has a body descriptor. This represents a union of the parent's body
// descriptor, and a new descriptor for the child -- so, both parent and child's
// slots are iterated. The parent must be fixed size, and its slots be disjoint
// with the child's.
template <class ParentBodyDescriptor, class ChildBodyDescriptor>
class SubclassBodyDescriptor final : public BodyDescriptorBase {
 public:
  // The parent must end be before the child's start offset, to make sure that
  // their slots are disjoint.
  STATIC_ASSERT(ParentBodyDescriptor::kSize <=
                ChildBodyDescriptor::kStartOffset);

162
  static bool IsValidSlot(Map map, HeapObject obj, int offset) {
163 164 165 166 167
    return ParentBodyDescriptor::IsValidSlot(map, obj, offset) ||
           ChildBodyDescriptor::IsValidSlot(map, obj, offset);
  }

  template <typename ObjectVisitor>
168
  static inline void IterateBody(Map map, HeapObject obj, ObjectVisitor* v) {
169 170 171 172 173
    ParentBodyDescriptor::IterateBody(map, obj, v);
    ChildBodyDescriptor::IterateBody(map, obj, v);
  }

  template <typename ObjectVisitor>
174
  static inline void IterateBody(Map map, HeapObject obj, int object_size,
175 176 177 178 179
                                 ObjectVisitor* v) {
    ParentBodyDescriptor::IterateBody(map, obj, object_size, v);
    ChildBodyDescriptor::IterateBody(map, obj, object_size, v);
  }

180
  static inline int SizeOf(Map map, HeapObject object) {
181 182 183 184 185
    // The child should know its full size.
    return ChildBodyDescriptor::SizeOf(map, object);
  }
};

186 187 188 189
}  // namespace internal
}  // namespace v8

#endif  // V8_OBJECTS_BODY_DESCRIPTORS_H_