V8 API Reference, 7.2.502.16 (for Deno 0.2.4)
access-info.h
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
3 // found in the LICENSE file.
4 
5 #ifndef V8_COMPILER_ACCESS_INFO_H_
6 #define V8_COMPILER_ACCESS_INFO_H_
7 
8 #include <iosfwd>
9 
10 #include "src/compiler/types.h"
11 #include "src/field-index.h"
12 #include "src/machine-type.h"
13 #include "src/objects.h"
14 #include "src/objects/map.h"
15 #include "src/zone/zone-containers.h"
16 
17 namespace v8 {
18 namespace internal {
19 
20 // Forward declarations.
21 class Factory;
22 
23 namespace compiler {
24 
25 // Forward declarations.
26 class CompilationDependencies;
27 class Type;
28 class TypeCache;
29 
30 // Whether we are loading a property or storing to a property.
31 // For a store during literal creation, do not walk up the prototype chain.
32 enum class AccessMode { kLoad, kStore, kStoreInLiteral };
33 
34 std::ostream& operator<<(std::ostream&, AccessMode);
35 
36 // Mapping of transition source to transition target.
37 typedef std::vector<std::pair<Handle<Map>, Handle<Map>>> MapTransitionList;
38 
39 // This class encapsulates all information required to access a certain element.
40 class ElementAccessInfo final {
41  public:
42  ElementAccessInfo();
43  ElementAccessInfo(MapHandles const& receiver_maps,
44  ElementsKind elements_kind);
45 
46  ElementsKind elements_kind() const { return elements_kind_; }
47  MapHandles const& receiver_maps() const { return receiver_maps_; }
48  MapTransitionList& transitions() { return transitions_; }
49  MapTransitionList const& transitions() const { return transitions_; }
50 
51  private:
52  ElementsKind elements_kind_;
53  MapHandles receiver_maps_;
54  MapTransitionList transitions_;
55 };
56 
57 // This class encapsulates all information required to access a certain
58 // object property, either on the object itself or on the prototype chain.
59 class PropertyAccessInfo final {
60  public:
61  enum Kind {
62  kInvalid,
63  kNotFound,
64  kDataConstant,
65  kDataField,
66  kDataConstantField,
67  kAccessorConstant,
68  kModuleExport,
69  kStringLength
70  };
71 
72  static PropertyAccessInfo NotFound(MapHandles const& receiver_maps,
73  MaybeHandle<JSObject> holder);
74  static PropertyAccessInfo DataConstant(MapHandles const& receiver_maps,
75  Handle<Object> constant,
76  MaybeHandle<JSObject> holder);
77  static PropertyAccessInfo DataField(
78  PropertyConstness constness, MapHandles const& receiver_maps,
79  FieldIndex field_index, MachineRepresentation field_representation,
80  Type field_type, MaybeHandle<Map> field_map = MaybeHandle<Map>(),
81  MaybeHandle<JSObject> holder = MaybeHandle<JSObject>(),
82  MaybeHandle<Map> transition_map = MaybeHandle<Map>());
83  static PropertyAccessInfo AccessorConstant(MapHandles const& receiver_maps,
84  Handle<Object> constant,
85  MaybeHandle<JSObject> holder);
86  static PropertyAccessInfo ModuleExport(MapHandles const& receiver_maps,
87  Handle<Cell> cell);
88  static PropertyAccessInfo StringLength(MapHandles const& receiver_maps);
89 
90  PropertyAccessInfo();
91 
92  bool Merge(PropertyAccessInfo const* that, AccessMode access_mode,
93  Zone* zone) V8_WARN_UNUSED_RESULT;
94 
95  bool IsNotFound() const { return kind() == kNotFound; }
96  bool IsDataConstant() const { return kind() == kDataConstant; }
97  bool IsDataField() const { return kind() == kDataField; }
98  // TODO(ishell): rename to IsDataConstant() once constant field tracking
99  // is done.
100  bool IsDataConstantField() const { return kind() == kDataConstantField; }
101  bool IsAccessorConstant() const { return kind() == kAccessorConstant; }
102  bool IsModuleExport() const { return kind() == kModuleExport; }
103  bool IsStringLength() const { return kind() == kStringLength; }
104 
105  bool HasTransitionMap() const { return !transition_map().is_null(); }
106 
107  Kind kind() const { return kind_; }
108  MaybeHandle<JSObject> holder() const { return holder_; }
109  MaybeHandle<Map> transition_map() const { return transition_map_; }
110  Handle<Object> constant() const { return constant_; }
111  FieldIndex field_index() const { return field_index_; }
112  Type field_type() const { return field_type_; }
113  MachineRepresentation field_representation() const {
114  return field_representation_;
115  }
116  MaybeHandle<Map> field_map() const { return field_map_; }
117  MapHandles const& receiver_maps() const { return receiver_maps_; }
118  Handle<Cell> export_cell() const;
119 
120  private:
121  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
122  MapHandles const& receiver_maps);
123  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
124  Handle<Object> constant, MapHandles const& receiver_maps);
125  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
126  MaybeHandle<Map> transition_map, FieldIndex field_index,
127  MachineRepresentation field_representation,
128  Type field_type, MaybeHandle<Map> field_map,
129  MapHandles const& receiver_maps);
130 
131  Kind kind_;
132  MapHandles receiver_maps_;
133  Handle<Object> constant_;
134  MaybeHandle<Map> transition_map_;
135  MaybeHandle<JSObject> holder_;
136  FieldIndex field_index_;
137  MachineRepresentation field_representation_;
138  Type field_type_;
139  MaybeHandle<Map> field_map_;
140 };
141 
142 
143 // Factory class for {ElementAccessInfo}s and {PropertyAccessInfo}s.
144 class AccessInfoFactory final {
145  public:
146  AccessInfoFactory(JSHeapBroker* broker, CompilationDependencies* dependencies,
147 
148  Handle<Context> native_context, Zone* zone);
149 
150  bool ComputeElementAccessInfo(Handle<Map> map, AccessMode access_mode,
151  ElementAccessInfo* access_info);
152  bool ComputeElementAccessInfos(MapHandles const& maps, AccessMode access_mode,
153  ZoneVector<ElementAccessInfo>* access_infos);
154  bool ComputePropertyAccessInfo(Handle<Map> map, Handle<Name> name,
155  AccessMode access_mode,
156  PropertyAccessInfo* access_info);
157  bool ComputePropertyAccessInfo(MapHandles const& maps, Handle<Name> name,
158  AccessMode access_mode,
159  PropertyAccessInfo* access_info);
160  bool ComputePropertyAccessInfos(MapHandles const& maps, Handle<Name> name,
161  AccessMode access_mode,
162  ZoneVector<PropertyAccessInfo>* access_infos);
163 
164  private:
165  bool ConsolidateElementLoad(MapHandles const& maps,
166  ElementAccessInfo* access_info);
167  bool LookupSpecialFieldAccessor(Handle<Map> map, Handle<Name> name,
168  PropertyAccessInfo* access_info);
169  bool LookupTransition(Handle<Map> map, Handle<Name> name,
170  MaybeHandle<JSObject> holder,
171  PropertyAccessInfo* access_info);
172 
173  CompilationDependencies* dependencies() const { return dependencies_; }
174  JSHeapBroker* broker() const { return broker_; }
175  Factory* factory() const;
176  Isolate* isolate() const { return isolate_; }
177  Handle<Context> native_context() const { return native_context_; }
178  Zone* zone() const { return zone_; }
179 
180  JSHeapBroker* const broker_;
181  CompilationDependencies* const dependencies_;
182  Handle<Context> const native_context_;
183  Isolate* const isolate_;
184  TypeCache const& type_cache_;
185  Zone* const zone_;
186 
187  DISALLOW_COPY_AND_ASSIGN(AccessInfoFactory);
188 };
189 
190 } // namespace compiler
191 } // namespace internal
192 } // namespace v8
193 
194 #endif // V8_COMPILER_ACCESS_INFO_H_
v8
Definition: libplatform.h:13