[turbofan] Utilize type information for alias analysis.

src/compiler/load-elimination.cc

 // Copyright 2016 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 "src/compiler/load-elimination.h"
 
 #include "src/compiler/js-graph.h"
 #include "src/compiler/node-properties.h"
 #include "src/compiler/simplified-operator.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 namespace {
 
 enum Aliasing { kNoAlias, kMayAlias, kMustAlias };
 
 Aliasing QueryAlias(Node* a, Node* b) {
   if (a == b) return kMustAlias;
+  if (!NodeProperties::GetType(a)->Maybe(NodeProperties::GetType(b))) {
+    return kNoAlias;
+  }
   if (b->opcode() == IrOpcode::kAllocate) {
     switch (a->opcode()) {
       case IrOpcode::kAllocate:
       case IrOpcode::kHeapConstant:
       case IrOpcode::kParameter:
         return kNoAlias;
       case IrOpcode::kFinishRegion:
         return QueryAlias(a->InputAt(0), b);
       default:
         break;
@@ skipping 73 matching lines @@
       AbstractElements* that = new (zone) AbstractElements(zone);
       for (Element const element : this->elements_) {
         if (element.object == nullptr) continue;
         DCHECK_NOT_NULL(element.index);
         DCHECK_NOT_NULL(element.value);
         if (!MayAlias(object, element.object) ||
             !MayAlias(index, element.index)) {
           that->elements_[that->next_index_++] = element;
         }
       }
+      that->next_index_ %= arraysize(elements_);
       return that;
     }
   }
   return this;
 }
 
 bool LoadElimination::AbstractElements::Equals(
     AbstractElements const* that) const {
   if (this == that) return true;
   for (size_t i = 0; i < arraysize(elements_); ++i) {
@@ skipping 33 matching lines @@
   for (Element const this_element : this->elements_) {
     if (this_element.object == nullptr) continue;
     for (Element const that_element : that->elements_) {
       if (this_element.object == that_element.object &&
           this_element.index == that_element.index &&
           this_element.value == that_element.value) {
         copy->elements_[copy->next_index_++] = this_element;
       }
     }
   }
+  copy->next_index_ %= arraysize(elements_);
   return copy;
 }
 
 Node* LoadElimination::AbstractField::Lookup(Node* object) const {
   for (auto pair : info_for_node_) {
     if (MustAlias(object, pair.first)) return pair.second;
   }
   return nullptr;
 }
 
@@ skipping 509 matching lines @@
   DCHECK_EQ(kTaggedBase, access.base_is_tagged);
   DCHECK_EQ(0, access.offset % kPointerSize);
   int field_index = access.offset / kPointerSize;
   if (field_index >= static_cast<int>(kMaxTrackedFields)) return -1;
   return field_index;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8