[turbofan] Perform element index computation in word64 on 64-bit platforms.

test/cctest/compiler/test-simplified-lowering.cc

 // Copyright 2014 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 <limits>
 
 #include "src/ast/scopes.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/control-builders.h"
 #include "src/compiler/effect-control-linearizer.h"
@@ skipping 1220 matching lines @@
 
 void CheckFieldAccessArithmetic(FieldAccess access, Node* load_or_store) {
   IntPtrMatcher mindex(load_or_store->InputAt(1));
   CHECK(mindex.Is(access.offset - access.tag()));
 }
 
 
 Node* CheckElementAccessArithmetic(ElementAccess access, Node* load_or_store) {
   Node* index = load_or_store->InputAt(1);
   if (kPointerSize == 8) {
+    Int64BinopMatcher mindex(index);
+    CHECK_EQ(IrOpcode::kInt64Add, mindex.node()->opcode());
+    CHECK(mindex.right().Is(access.header_size - access.tag()));
+
+    const int element_size_shift =
+        ElementSizeLog2Of(access.machine_type.representation());
+    Node* index;
+    if (element_size_shift) {
+      Int64BinopMatcher shl(mindex.left().node());
+      CHECK_EQ(IrOpcode::kWord64Shl, shl.node()->opcode());
+      CHECK(shl.right().Is(element_size_shift));
+      index = shl.left().node();
+    } else {
+      index = mindex.left().node();
+    }
     CHECK_EQ(IrOpcode::kChangeUint32ToUint64, index->opcode());
-    index = index->InputAt(0);
-  }
+    return index->InputAt(0);
+  } else {
+    Int32BinopMatcher mindex(index);
+    CHECK_EQ(IrOpcode::kInt32Add, mindex.node()->opcode());
+    CHECK(mindex.right().Is(access.header_size - access.tag()));
 
-  Int32BinopMatcher mindex(index);
-  CHECK_EQ(IrOpcode::kInt32Add, mindex.node()->opcode());
-  CHECK(mindex.right().Is(access.header_size - access.tag()));
-
-  const int element_size_shift =
-      ElementSizeLog2Of(access.machine_type.representation());
-  if (element_size_shift) {
-    Int32BinopMatcher shl(mindex.left().node());
-    CHECK_EQ(IrOpcode::kWord32Shl, shl.node()->opcode());
-    CHECK(shl.right().Is(element_size_shift));
-    return shl.left().node();
-  } else {
-    return mindex.left().node();
+    const int element_size_shift =
+        ElementSizeLog2Of(access.machine_type.representation());
+    if (element_size_shift) {
+      Int32BinopMatcher shl(mindex.left().node());
+      CHECK_EQ(IrOpcode::kWord32Shl, shl.node()->opcode());
+      CHECK(shl.right().Is(element_size_shift));
+      return shl.left().node();
+    } else {
+      return mindex.left().node();
+    }
   }
 }
 
 
 const MachineType kMachineReps[] = {
     MachineType::Int8(),     MachineType::Int16(), MachineType::Int32(),
     MachineType::Uint32(),   MachineType::Int64(), MachineType::Float64(),
     MachineType::AnyTagged()};
 
 }  // namespace
@@ skipping 633 matching lines @@
     t.Return(use);
     t.Lower();
 
     CHECK_EQ(d.expected, PhiRepresentationOf(phi->op()));
   }
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8