[turbofan] Merge PropertyAccessInfo for compatible field loads.

src/compiler/access-info.cc

 // 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.
 
 #include <ostream>
 
 #include "src/accessors.h"
 #include "src/compilation-dependencies.h"
 #include "src/compiler/access-info.h"
 #include "src/compiler/type-cache.h"
@@ skipping 115 matching lines @@
     Type* field_type, MaybeHandle<Map> field_map, MapList const& receiver_maps)
     : kind_(kind),
       receiver_maps_(receiver_maps),
       transition_map_(transition_map),
       holder_(holder),
       field_index_(field_index),
       field_representation_(field_representation),
       field_type_(field_type),
       field_map_(field_map) {}
 
-bool PropertyAccessInfo::Merge(PropertyAccessInfo const* that) {
+bool PropertyAccessInfo::Merge(PropertyAccessInfo const* that,
+                               AccessMode access_mode, Zone* zone) {
   if (this->kind_ != that->kind_) return false;
   if (this->holder_.address() != that->holder_.address()) return false;
 
   switch (this->kind_) {
     case kInvalid:
       break;
 
     case kDataField:
     case kDataConstantField: {
       // Check if we actually access the same field.
       if (this->kind_ == that->kind_ &&
-          this->transition_map_.address() == that->transition_map_.address() &&
-          this->field_index_ == that->field_index_ &&
-          this->field_map_.address() == that->field_map_.address() &&
-          this->field_type_->Is(that->field_type_) &&
-          that->field_type_->Is(this->field_type_) &&
-          this->field_representation_ == that->field_representation_) {
+          this->field_index_ == that->field_index_) {
+        switch (access_mode) {
+          case AccessMode::kLoad: {
+            if (this->field_representation_ != that->field_representation_) {
+              if (!IsAnyTagged(this->field_representation_) ||
+                  !IsAnyTagged(that->field_representation_)) {
+                return false;
+              }
+              this->field_representation_ = MachineRepresentation::kTagged;
+            }
+            if (this->field_map_.address() != that->field_map_.address()) {
+              this->field_map_ = MaybeHandle<Map>();
+            }
+            break;
+          }
+          case AccessMode::kStore:
+          case AccessMode::kStoreInLiteral: {
+            // For stores, the field map and field representation information
+            // must match exactly, otherwise we cannot merge the stores. We
+            // also need to make sure that in case of transitioning stores,
+            // the transition targets match.
+            if (this->field_map_.address() != that->field_map_.address() ||
+                this->field_representation_ != that->field_representation_ ||
+                this->transition_map_.address() !=
+                    that->transition_map_.address()) {
+              return false;
+            }
+            break;
+          }
+        }
+        // Merge the field type.
+        this->field_type_ =
+            Type::Union(this->field_type_, that->field_type_, zone);
+        // Merge the receiver maps.
         this->receiver_maps_.insert(this->receiver_maps_.end(),
                                     that->receiver_maps_.begin(),
                                     that->receiver_maps_.end());
         return true;
       }
       return false;
     }
 
     case kDataConstant:
     case kAccessorConstant: {
@@ skipping 282 matching lines @@
     ZoneVector<PropertyAccessInfo>* access_infos) {
   for (Handle<Map> map : maps) {
     if (Map::TryUpdate(map).ToHandle(&map)) {
       PropertyAccessInfo access_info;
       if (!ComputePropertyAccessInfo(map, name, access_mode, &access_info)) {
         return false;
       }
       // Try to merge the {access_info} with an existing one.
       bool merged = false;
       for (PropertyAccessInfo& other_info : *access_infos) {
-        if (other_info.Merge(&access_info)) {
+        if (other_info.Merge(&access_info, access_mode, zone())) {
           merged = true;
           break;
         }
       }
       if (!merged) access_infos->push_back(access_info);
     }
   }
   return true;
 }
 
@@ skipping 95 matching lines @@
   }
   return false;
 }
 
 
 Factory* AccessInfoFactory::factory() const { return isolate()->factory(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8