compilation-dependencies.h 5.54 KB
Newer Older
1 2 3 4
// 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.

5 6
#ifndef V8_COMPILER_COMPILATION_DEPENDENCIES_H_
#define V8_COMPILER_COMPILATION_DEPENDENCIES_H_
7

8
#include "src/compiler/js-heap-broker.h"
9
#include "src/objects/objects.h"
10
#include "src/zone/zone-containers.h"
11

12 13
namespace v8 {
namespace internal {
14
namespace compiler {
15

16 17 18 19 20 21 22 23 24 25 26 27
class SlackTrackingPrediction {
 public:
  SlackTrackingPrediction(MapRef initial_map, int instance_size);

  int inobject_property_count() const { return inobject_property_count_; }
  int instance_size() const { return instance_size_; }

 private:
  int instance_size_;
  int inobject_property_count_;
};

28 29
class CompilationDependency;

30
// Collects and installs dependencies of the code that is being generated.
31
class V8_EXPORT_PRIVATE CompilationDependencies : public ZoneObject {
32
 public:
33
  CompilationDependencies(JSHeapBroker* broker, Zone* zone);
34 35 36 37

  V8_WARN_UNUSED_RESULT bool Commit(Handle<Code> code);

  // Return the initial map of {function} and record the assumption that it
38
  // stays the initial map.
39
  MapRef DependOnInitialMap(const JSFunctionRef& function);
40

41 42 43 44
  // Return the "prototype" property of the given function and record the
  // assumption that it doesn't change.
  ObjectRef DependOnPrototypeProperty(const JSFunctionRef& function);

45
  // Record the assumption that {map} stays stable.
46
  void DependOnStableMap(const MapRef& map);
47 48 49

  // Record the assumption that {target_map} can be transitioned to, i.e., that
  // it does not become deprecated.
50
  void DependOnTransition(const MapRef& target_map);
51 52 53

  // Return the pretenure mode of {site} and record the assumption that it does
  // not change.
54
  AllocationType DependOnPretenureMode(const AllocationSiteRef& site);
55

56 57
  // Record the assumption that the field representation of a field does not
  // change. The field is identified by the arguments.
58
  void DependOnFieldRepresentation(const MapRef& map, InternalIndex descriptor);
59

60
  // Record the assumption that the field type of a field does not change. The
61
  // field is identified by the arguments.
62
  void DependOnFieldType(const MapRef& map, InternalIndex descriptor);
63

64 65 66 67 68 69 70
  // Return a field's constness and, if kConst, record the assumption that it
  // remains kConst. The field is identified by the arguments.
  //
  // For arrays, arguments objects and value wrappers, only consider the field
  // kConst if the map is stable (and register stability dependency in that
  // case).  This is to ensure that fast elements kind transitions cannot be
  // used to mutate fields without deoptimization of the dependent code.
71 72
  PropertyConstness DependOnFieldConstness(const MapRef& map,
                                           InternalIndex descriptor);
73

74 75
  // Record the assumption that neither {cell}'s {CellType} changes, nor the
  // {IsReadOnly()} flag of {cell}'s {PropertyDetails}.
76
  void DependOnGlobalProperty(const PropertyCellRef& cell);
77

78 79 80 81 82 83 84 85 86 87 88 89
  // Return the validity of the given protector and, if true, record the
  // assumption that the protector remains valid.
  bool DependOnProtector(const PropertyCellRef& cell);

  // Convenience wrappers around {DependOnProtector}.
  bool DependOnArrayBufferDetachingProtector();
  bool DependOnArrayIteratorProtector();
  bool DependOnArraySpeciesProtector();
  bool DependOnNoElementsProtector();
  bool DependOnPromiseHookProtector();
  bool DependOnPromiseSpeciesProtector();
  bool DependOnPromiseThenProtector();
90 91

  // Record the assumption that {site}'s {ElementsKind} doesn't change.
92
  void DependOnElementsKind(const AllocationSiteRef& site);
93

94 95 96
  // For each given map, depend on the stability of (the maps of) all prototypes
  // up to (and including) the {last_prototype}.
  template <class MapContainer>
97
  void DependOnStablePrototypeChains(
98 99 100
      MapContainer const& receiver_maps, WhereToStart start,
      base::Optional<JSObjectRef> last_prototype =
          base::Optional<JSObjectRef>());
101 102

  // Like DependOnElementsKind but also applies to all nested allocation sites.
103
  void DependOnElementsKinds(const AllocationSiteRef& site);
104

105 106 107 108 109 110 111 112
  // Predict the final instance size for {function}'s initial map and record
  // the assumption that this prediction is correct. In addition, register
  // the initial map dependency. This method returns the {function}'s the
  // predicted minimum slack instance size count (wrapped together with
  // the corresponding in-object property count for convenience).
  SlackTrackingPrediction DependOnInitialMapInstanceSizePrediction(
      const JSFunctionRef& function);

113 114 115 116 117 118
  // The methods below allow for gathering dependencies without actually
  // recording them. They can be recorded at a later time (or they can be
  // ignored). For example,
  //   DependOnTransition(map);
  // is equivalent to:
  //   RecordDependency(TransitionDependencyOffTheRecord(map));
119 120
  void RecordDependency(CompilationDependency const* dependency);
  CompilationDependency const* TransitionDependencyOffTheRecord(
121
      const MapRef& target_map) const;
122
  CompilationDependency const* FieldRepresentationDependencyOffTheRecord(
123
      const MapRef& map, InternalIndex descriptor) const;
124
  CompilationDependency const* FieldTypeDependencyOffTheRecord(
125
      const MapRef& map, InternalIndex descriptor) const;
126

127 128 129
  // Exposed only for testing purposes.
  bool AreValid() const;

130
 private:
131 132
  Zone* const zone_;
  JSHeapBroker* const broker_;
133
  ZoneForwardList<CompilationDependency const*> dependencies_;
134
};
135

136
}  // namespace compiler
137 138
}  // namespace internal
}  // namespace v8
139

140
#endif  // V8_COMPILER_COMPILATION_DEPENDENCIES_H_