BASELINE: Update Chromium to 76.0.3809.94

Change-Id: I321c3f5f929c105aec0f98c5091ef6108822e647
Reviewed-by: Michael Brüning <michael.bruning@qt.io>

1 files changed, 86 insertions, 61 deletions

diff --git a/chromium/v8/src/compiler/access-info.h b/chromium/v8/src/compiler/access-info.h
index 19453039294..3499069fc44 100644
--- a/chromium/v8/src/compiler/access-info.h
+++ b/chromium/v8/src/compiler/access-info.h
@@ -7,12 +7,13 @@
 
 #include <iosfwd>
 
+#include "src/codegen/machine-type.h"
+#include "src/compiler/compilation-dependencies.h"
 #include "src/compiler/types.h"
-#include "src/feedback-vector.h"
-#include "src/field-index.h"
-#include "src/machine-type.h"
-#include "src/objects.h"
+#include "src/objects/feedback-vector.h"
+#include "src/objects/field-index.h"
 #include "src/objects/map.h"
+#include "src/objects/objects.h"
 #include "src/zone/zone-containers.h"
 
 namespace v8 {
@@ -24,27 +25,25 @@ class Factory;
 namespace compiler {
 
 // Forward declarations.
-class CompilationDependencies;
 class ElementAccessFeedback;
 class Type;
 class TypeCache;
 
-// Whether we are loading a property or storing to a property.
-// For a store during literal creation, do not walk up the prototype chain.
-enum class AccessMode { kLoad, kStore, kStoreInLiteral, kHas };
-
 std::ostream& operator<<(std::ostream&, AccessMode);
 
 // This class encapsulates all information required to access a certain element.
 class ElementAccessInfo final {
  public:
-  ElementAccessInfo();
-  ElementAccessInfo(MapHandles const& receiver_maps,
-                    ElementsKind elements_kind);
+  ElementAccessInfo(ZoneVector<Handle<Map>>&& receiver_maps,
+                    ElementsKind elements_kind, Zone* zone);
 
   ElementsKind elements_kind() const { return elements_kind_; }
-  MapHandles const& receiver_maps() const { return receiver_maps_; }
-  MapHandles const& transition_sources() const { return transition_sources_; }
+  ZoneVector<Handle<Map>> const& receiver_maps() const {
+    return receiver_maps_;
+  }
+  ZoneVector<Handle<Map>> const& transition_sources() const {
+    return transition_sources_;
+  }
 
   void AddTransitionSource(Handle<Map> map) {
     CHECK_EQ(receiver_maps_.size(), 1);
@@ -53,8 +52,8 @@ class ElementAccessInfo final {
 
  private:
   ElementsKind elements_kind_;
-  MapHandles receiver_maps_;
-  MapHandles transition_sources_;
+  ZoneVector<Handle<Map>> receiver_maps_;
+  ZoneVector<Handle<Map>> transition_sources_;
 };
 
 // This class encapsulates all information required to access a certain
@@ -64,44 +63,48 @@ class PropertyAccessInfo final {
   enum Kind {
     kInvalid,
     kNotFound,
-    kDataConstant,
     kDataField,
-    kDataConstantField,
+    kDataConstant,
     kAccessorConstant,
     kModuleExport,
     kStringLength
   };
 
-  static PropertyAccessInfo NotFound(MapHandles const& receiver_maps,
+  static PropertyAccessInfo NotFound(Zone* zone, Handle<Map> receiver_map,
                                      MaybeHandle<JSObject> holder);
-  static PropertyAccessInfo DataConstant(MapHandles const& receiver_maps,
-                                         Handle<Object> constant,
-                                         MaybeHandle<JSObject> holder);
   static PropertyAccessInfo DataField(
-      PropertyConstness constness, MapHandles const& receiver_maps,
-      FieldIndex field_index, MachineRepresentation field_representation,
+      Zone* zone, Handle<Map> receiver_map,
+      ZoneVector<CompilationDependencies::Dependency const*>&&
+          unrecorded_dependencies,
+      FieldIndex field_index, Representation field_representation,
       Type field_type, MaybeHandle<Map> field_map = MaybeHandle<Map>(),
       MaybeHandle<JSObject> holder = MaybeHandle<JSObject>(),
       MaybeHandle<Map> transition_map = MaybeHandle<Map>());
-  static PropertyAccessInfo AccessorConstant(MapHandles const& receiver_maps,
+  static PropertyAccessInfo DataConstant(
+      Zone* zone, Handle<Map> receiver_map,
+      ZoneVector<CompilationDependencies::Dependency const*>&&
+          unrecorded_dependencies,
+      FieldIndex field_index, Representation field_representation,
+      Type field_type, MaybeHandle<Map> field_map, MaybeHandle<JSObject> holder,
+      MaybeHandle<Map> transition_map = MaybeHandle<Map>());
+  static PropertyAccessInfo AccessorConstant(Zone* zone,
+                                             Handle<Map> receiver_map,
                                              Handle<Object> constant,
                                              MaybeHandle<JSObject> holder);
-  static PropertyAccessInfo ModuleExport(MapHandles const& receiver_maps,
+  static PropertyAccessInfo ModuleExport(Zone* zone, Handle<Map> receiver_map,
                                          Handle<Cell> cell);
-  static PropertyAccessInfo StringLength(MapHandles const& receiver_maps);
-
-  PropertyAccessInfo();
+  static PropertyAccessInfo StringLength(Zone* zone, Handle<Map> receiver_map);
+  static PropertyAccessInfo Invalid(Zone* zone);
 
   bool Merge(PropertyAccessInfo const* that, AccessMode access_mode,
              Zone* zone) V8_WARN_UNUSED_RESULT;
 
+  void RecordDependencies(CompilationDependencies* dependencies);
+
   bool IsInvalid() const { return kind() == kInvalid; }
   bool IsNotFound() const { return kind() == kNotFound; }
-  bool IsDataConstant() const { return kind() == kDataConstant; }
   bool IsDataField() const { return kind() == kDataField; }
-  // TODO(ishell): rename to IsDataConstant() once constant field tracking
-  // is done.
-  bool IsDataConstantField() const { return kind() == kDataConstantField; }
+  bool IsDataConstant() const { return kind() == kDataConstant; }
   bool IsAccessorConstant() const { return kind() == kAccessorConstant; }
   bool IsModuleExport() const { return kind() == kModuleExport; }
   bool IsStringLength() const { return kind() == kStringLength; }
@@ -109,36 +112,46 @@ class PropertyAccessInfo final {
   bool HasTransitionMap() const { return !transition_map().is_null(); }
 
   Kind kind() const { return kind_; }
-  MaybeHandle<JSObject> holder() const { return holder_; }
+  MaybeHandle<JSObject> holder() const {
+    // This CHECK tries to protect against using the access info without
+    // recording its dependencies first.
+    CHECK(unrecorded_dependencies_.empty());
+    return holder_;
+  }
   MaybeHandle<Map> transition_map() const { return transition_map_; }
   Handle<Object> constant() const { return constant_; }
   FieldIndex field_index() const { return field_index_; }
   Type field_type() const { return field_type_; }
-  MachineRepresentation field_representation() const {
-    return field_representation_;
-  }
+  Representation field_representation() const { return field_representation_; }
   MaybeHandle<Map> field_map() const { return field_map_; }
-  MapHandles const& receiver_maps() const { return receiver_maps_; }
+  ZoneVector<Handle<Map>> const& receiver_maps() const {
+    return receiver_maps_;
+  }
   Handle<Cell> export_cell() const;
 
  private:
-  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
-                     MapHandles const& receiver_maps);
-  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
-                     Handle<Object> constant, MapHandles const& receiver_maps);
-  PropertyAccessInfo(Kind kind, MaybeHandle<JSObject> holder,
-                     MaybeHandle<Map> transition_map, FieldIndex field_index,
-                     MachineRepresentation field_representation,
-                     Type field_type, MaybeHandle<Map> field_map,
-                     MapHandles const& receiver_maps);
+  explicit PropertyAccessInfo(Zone* zone);
+  PropertyAccessInfo(Zone* zone, Kind kind, MaybeHandle<JSObject> holder,
+                     ZoneVector<Handle<Map>>&& receiver_maps);
+  PropertyAccessInfo(Zone* zone, Kind kind, MaybeHandle<JSObject> holder,
+                     Handle<Object> constant,
+                     ZoneVector<Handle<Map>>&& receiver_maps);
+  PropertyAccessInfo(
+      Kind kind, MaybeHandle<JSObject> holder, MaybeHandle<Map> transition_map,
+      FieldIndex field_index, Representation field_representation,
+      Type field_type, MaybeHandle<Map> field_map,
+      ZoneVector<Handle<Map>>&& receiver_maps,
+      ZoneVector<CompilationDependencies::Dependency const*>&& dependencies);
 
   Kind kind_;
-  MapHandles receiver_maps_;
+  ZoneVector<Handle<Map>> receiver_maps_;
+  ZoneVector<CompilationDependencies::Dependency const*>
+      unrecorded_dependencies_;
   Handle<Object> constant_;
   MaybeHandle<Map> transition_map_;
   MaybeHandle<JSObject> holder_;
   FieldIndex field_index_;
-  MachineRepresentation field_representation_;
+  Representation field_representation_;
   Type field_type_;
   MaybeHandle<Map> field_map_;
 };
@@ -150,31 +163,38 @@ class AccessInfoFactory final {
   AccessInfoFactory(JSHeapBroker* broker, CompilationDependencies* dependencies,
                     Zone* zone);
 
-  bool ComputeElementAccessInfo(Handle<Map> map, AccessMode access_mode,
-                                ElementAccessInfo* access_info) const;
+  base::Optional<ElementAccessInfo> ComputeElementAccessInfo(
+      Handle<Map> map, AccessMode access_mode) const;
   bool ComputeElementAccessInfos(
-      FeedbackNexus nexus, MapHandles const& maps, AccessMode access_mode,
+      ElementAccessFeedback const& processed, AccessMode access_mode,
       ZoneVector<ElementAccessInfo>* access_infos) const;
 
   PropertyAccessInfo ComputePropertyAccessInfo(Handle<Map> map,
                                                Handle<Name> name,
                                                AccessMode access_mode) const;
-  PropertyAccessInfo ComputePropertyAccessInfo(MapHandles const& maps,
-                                               Handle<Name> name,
-                                               AccessMode access_mode) const;
+
+  // Convenience wrapper around {ComputePropertyAccessInfo} for multiple maps.
   void ComputePropertyAccessInfos(
       MapHandles const& maps, Handle<Name> name, AccessMode access_mode,
       ZoneVector<PropertyAccessInfo>* access_infos) const;
 
-  // Merge as many of the given {infos} as possible. Return false iff
-  // any of them was invalid.
+  // Merge as many of the given {infos} as possible and record any dependencies.
+  // Return false iff any of them was invalid, in which case no dependencies are
+  // recorded.
+  // TODO(neis): Make access_mode part of access info?
   bool FinalizePropertyAccessInfos(
       ZoneVector<PropertyAccessInfo> infos, AccessMode access_mode,
       ZoneVector<PropertyAccessInfo>* result) const;
 
+  // Merge the given {infos} to a single one and record any dependencies. If the
+  // merge is not possible, the result has kind {kInvalid} and no dependencies
+  // are recorded.
+  PropertyAccessInfo FinalizePropertyAccessInfosAsOne(
+      ZoneVector<PropertyAccessInfo> infos, AccessMode access_mode) const;
+
  private:
-  bool ConsolidateElementLoad(ElementAccessFeedback const& processed,
-                              ElementAccessInfo* access_info) const;
+  base::Optional<ElementAccessInfo> ConsolidateElementLoad(
+      ElementAccessFeedback const& processed) const;
   PropertyAccessInfo LookupSpecialFieldAccessor(Handle<Map> map,
                                                 Handle<Name> name) const;
   PropertyAccessInfo LookupTransition(Handle<Map> map, Handle<Name> name,
@@ -182,11 +202,16 @@ class AccessInfoFactory final {
   PropertyAccessInfo ComputeDataFieldAccessInfo(Handle<Map> receiver_map,
                                                 Handle<Map> map,
                                                 MaybeHandle<JSObject> holder,
-                                                int number,
+                                                int descriptor,
                                                 AccessMode access_mode) const;
   PropertyAccessInfo ComputeAccessorDescriptorAccessInfo(
       Handle<Map> receiver_map, Handle<Name> name, Handle<Map> map,
-      MaybeHandle<JSObject> holder, int number, AccessMode access_mode) const;
+      MaybeHandle<JSObject> holder, int descriptor,
+      AccessMode access_mode) const;
+
+  void MergePropertyAccessInfos(ZoneVector<PropertyAccessInfo> infos,
+                                AccessMode access_mode,
+                                ZoneVector<PropertyAccessInfo>* result) const;
 
   CompilationDependencies* dependencies() const { return dependencies_; }
   JSHeapBroker* broker() const { return broker_; }