Fix int64 lowering on big-endian architectures.

test/unittests/compiler/int64-lowering-unittest.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/int64-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
 #include "src/compiler/node.h"
 
@@ skipping 115 matching lines @@
 TEST_F(Int64LoweringTest, Int64Load) {
   int32_t base = 0x1234;
   int32_t index = 0x5678;
 
   LowerGraph(graph()->NewNode(machine()->Load(MachineType::Int64()),
                               Int32Constant(base), Int32Constant(index),
                               start(), start()),
              MachineRepresentation::kWord64);
 
   Capture<Node*> high_word_load;
+#if defined(V8_TARGET_LITTLE_ENDIAN)
   Matcher<Node*> high_word_load_matcher =
       IsLoad(MachineType::Int32(), IsInt32Constant(base),
              IsInt32Add(IsInt32Constant(index), IsInt32Constant(0x4)), start(),
              start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(IsLoad(MachineType::Int32(), IsInt32Constant(base),
                        IsInt32Constant(index), AllOf(CaptureEq(&high_word_load),
                                                      high_word_load_matcher),
                        start()),
                 AllOf(CaptureEq(&high_word_load), high_word_load_matcher),
                 start(), start()));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+  Matcher<Node*> high_word_load_matcher =
+      IsLoad(MachineType::Int32(), IsInt32Constant(base),
+             IsInt32Constant(index), start(), start());
+
+  EXPECT_THAT(
+      graph()->end()->InputAt(1),
+      IsReturn2(
+          IsLoad(MachineType::Int32(), IsInt32Constant(base),
+                 IsInt32Add(IsInt32Constant(index), IsInt32Constant(0x4)),
+                 AllOf(CaptureEq(&high_word_load), high_word_load_matcher),
+                 start()),
+          AllOf(CaptureEq(&high_word_load), high_word_load_matcher), start(),
+          start()));
+#endif
 }
 
 TEST_F(Int64LoweringTest, Int64Store) {
   // We have to build the TF graph explicitly here because Store does not return
   // a value.
 
   int32_t base = 1111;
   int32_t index = 2222;
   int32_t return_value = 0x5555;
 
@@ skipping 11 matching lines @@
 
   NodeProperties::MergeControlToEnd(graph(), common(), ret);
 
   Int64Lowering lowering(graph(), machine(), common(), zone(),
                          sig_builder.Build());
   lowering.LowerGraph();
 
   const StoreRepresentation rep(MachineRepresentation::kWord32,
                                 kNoWriteBarrier);
 
+#if defined(V8_TARGET_LITTLE_ENDIAN)
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn(
           IsInt32Constant(return_value),
           IsStore(
               rep, IsInt32Constant(base), IsInt32Constant(index),
               IsInt32Constant(low_word_value(0)),
               IsStore(rep, IsInt32Constant(base),
                       IsInt32Add(IsInt32Constant(index), IsInt32Constant(4)),
                       IsInt32Constant(high_word_value(0)), start(), start()),
               start()),
           start()));
+#elif defined(V8_TARGET_BIG_ENDIAN)
+  EXPECT_THAT(
+      graph()->end()->InputAt(1),
+      IsReturn(
+          IsInt32Constant(return_value),
+          IsStore(
+              rep, IsInt32Constant(base),
+              IsInt32Add(IsInt32Constant(index), IsInt32Constant(4)),
+              IsInt32Constant(low_word_value(0)),
+              IsStore(rep, IsInt32Constant(base), IsInt32Constant(index),
+                      IsInt32Constant(high_word_value(0)), start(), start()),
+              start()),
+          start()));
+#endif
 }
 
 TEST_F(Int64LoweringTest, Int64And) {
   LowerGraph(graph()->NewNode(machine()->Word64And(), Int64Constant(value(0)),
                               Int64Constant(value(1))),
              MachineRepresentation::kWord64);
   EXPECT_THAT(graph()->end()->InputAt(1),
               IsReturn2(IsWord32And(IsInt32Constant(low_word_value(0)),
                                     IsInt32Constant(low_word_value(1))),
                         IsWord32And(IsInt32Constant(high_word_value(0)),
@@ skipping 317 matching lines @@
 
   Capture<Node*> stack_slot_capture;
   Matcher<Node*> stack_slot_matcher =
       IsStackSlot(MachineRepresentation::kWord64);
 
   Capture<Node*> store_capture;
   Matcher<Node*> store_matcher =
       IsStore(StoreRepresentation(MachineRepresentation::kWord32,
                                   WriteBarrierKind::kNoWriteBarrier),
               AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
-              IsInt32Constant(0), IsInt32Constant(low_word_value(0)),
+              IsInt32Constant(Int64Lowering::kLowerWordOffset),
+              IsInt32Constant(low_word_value(0)),
               IsStore(StoreRepresentation(MachineRepresentation::kWord32,
                                           WriteBarrierKind::kNoWriteBarrier),
                       AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
-                      IsInt32Constant(4), IsInt32Constant(high_word_value(0)),
-                      start(), start()),
+                      IsInt32Constant(Int64Lowering::kHigherWordOffset),
+                      IsInt32Constant(high_word_value(0)), start(), start()),
               start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn(IsLoad(MachineType::Float64(),
                       AllOf(CaptureEq(&stack_slot_capture), stack_slot_matcher),
                       IsInt32Constant(0),
                       AllOf(CaptureEq(&store_capture), store_matcher), start()),
                start(), start()));
 }
@@ skipping 11 matching lines @@
   Matcher<Node*> store_matcher = IsStore(
       StoreRepresentation(MachineRepresentation::kFloat64,
                           WriteBarrierKind::kNoWriteBarrier),
       AllOf(CaptureEq(&stack_slot), stack_slot_matcher), IsInt32Constant(0),
       IsFloat64Constant(bit_cast<double>(value(0))), start(), start());
 
   EXPECT_THAT(
       graph()->end()->InputAt(1),
       IsReturn2(IsLoad(MachineType::Int32(),
                        AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
-                       IsInt32Constant(0),
+                       IsInt32Constant(Int64Lowering::kLowerWordOffset),
                        AllOf(CaptureEq(&store), store_matcher), start()),
                 IsLoad(MachineType::Int32(),
                        AllOf(CaptureEq(&stack_slot), stack_slot_matcher),
-                       IsInt32Constant(0x4),
+                       IsInt32Constant(Int64Lowering::kHigherWordOffset),
                        AllOf(CaptureEq(&store), store_matcher), start()),
                 start(), start()));
 }
 
 TEST_F(Int64LoweringTest, I64Clz) {
   LowerGraph(graph()->NewNode(machine()->Word64Clz(), Int64Constant(value(0))),
              MachineRepresentation::kWord64);
 
   Capture<Node*> branch_capture;
   Matcher<Node*> branch_matcher = IsBranch(
@@ skipping 202 matching lines @@
           Float32Constant(2.5));
 }
 
 TEST_F(Int64LoweringTest, I64PhiWord32) {
   TestPhi(this, MachineRepresentation::kWord32, Float32Constant(1),
           Float32Constant(2));
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8