Implement optional turbofan UnalignedLoad and UnalignedStore operators

src/compiler/int64-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 "src/compiler/int64-lowering.h"
 #include "src/compiler/common-operator.h"
 #include "src/compiler/diamond.h"
 #include "src/compiler/graph.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/machine-operator.h"
@@ skipping 89 matching lines @@
   switch (node->opcode()) {
     case IrOpcode::kInt64Constant: {
       int64_t value = OpParameter<int64_t>(node);
       Node* low_node = graph()->NewNode(
           common()->Int32Constant(static_cast<int32_t>(value & 0xFFFFFFFF)));
       Node* high_node = graph()->NewNode(
           common()->Int32Constant(static_cast<int32_t>(value >> 32)));
       ReplaceNode(node, low_node, high_node);
       break;
     }
-    case IrOpcode::kLoad: {
-      LoadRepresentation load_rep = LoadRepresentationOf(node->op());
+    case IrOpcode::kLoad:
+    case IrOpcode::kUnalignedLoad: {
+      MachineRepresentation rep;
+      if (node->opcode() == IrOpcode::kLoad) {
+        rep = LoadRepresentationOf(node->op()).representation();
+      } else {
+        DCHECK(node->opcode() == IrOpcode::kUnalignedLoad);
+        rep = UnalignedLoadRepresentationOf(node->op()).representation();
+      }
 
-      if (load_rep.representation() == MachineRepresentation::kWord64) {
+      if (rep == MachineRepresentation::kWord64) {
         Node* base = node->InputAt(0);
         Node* index = node->InputAt(1);
         Node* index_high =
             graph()->NewNode(machine()->Int32Add(), index,
                              graph()->NewNode(common()->Int32Constant(4)));
 
-        const Operator* load_op = machine()->Load(MachineType::Int32());
+        const Operator* load_op;
+        if (node->opcode() == IrOpcode::kLoad) {
+          load_op = machine()->Load(MachineType::Int32());
+        } else {
+          DCHECK(node->opcode() == IrOpcode::kUnalignedLoad);
+          load_op = machine()->UnalignedLoad(MachineType::Int32()).op();
+        }
+
         Node* high_node;
         if (node->InputCount() > 2) {
           Node* effect_high = node->InputAt(2);
           Node* control_high = node->InputAt(3);
           high_node = graph()->NewNode(load_op, base, index_high, effect_high,
                                        control_high);
           // change the effect change from old_node --> old_effect to
           // old_node --> high_node --> old_effect.
           node->ReplaceInput(2, high_node);
         } else {
           high_node = graph()->NewNode(load_op, base, index_high);
         }
         NodeProperties::ChangeOp(node, load_op);
         ReplaceNode(node, node, high_node);
       } else {
         DefaultLowering(node);
       }
       break;
     }
-    case IrOpcode::kStore: {
-      StoreRepresentation store_rep = StoreRepresentationOf(node->op());
-      if (store_rep.representation() == MachineRepresentation::kWord64) {
+    case IrOpcode::kStore:
+    case IrOpcode::kUnalignedStore: {
+      MachineRepresentation rep;
+      if (node->opcode() == IrOpcode::kStore) {
+        rep = StoreRepresentationOf(node->op()).representation();
+      } else {
+        DCHECK(node->opcode() == IrOpcode::kUnalignedStore);
+        rep = UnalignedStoreRepresentationOf(node->op());
+      }
+
+      if (rep == MachineRepresentation::kWord64) {
         // We change the original store node to store the low word, and create
         // a new store node to store the high word. The effect and control edges
         // are copied from the original store to the new store node, the effect
         // edge of the original store is redirected to the new store.
-        WriteBarrierKind write_barrier_kind = store_rep.write_barrier_kind();
-
         Node* base = node->InputAt(0);
         Node* index = node->InputAt(1);
         Node* index_high =
             graph()->NewNode(machine()->Int32Add(), index,
                              graph()->NewNode(common()->Int32Constant(4)));
 
         Node* value = node->InputAt(2);
         DCHECK(HasReplacementLow(value));
         DCHECK(HasReplacementHigh(value));
 
-        const Operator* store_op = machine()->Store(StoreRepresentation(
-            MachineRepresentation::kWord32, write_barrier_kind));
+        const Operator* store_op;
+        if (node->opcode() == IrOpcode::kStore) {
+          WriteBarrierKind write_barrier_kind =
+              StoreRepresentationOf(node->op()).write_barrier_kind();
+          store_op = machine()->Store(StoreRepresentation(
+              MachineRepresentation::kWord32, write_barrier_kind));
+        } else {
+          DCHECK(node->opcode() == IrOpcode::kUnalignedStore);
+          store_op =
+              machine()->UnalignedStore(MachineRepresentation::kWord32).op();
+        }
 
         Node* high_node;
         if (node->InputCount() > 3) {
           Node* effect_high = node->InputAt(3);
           Node* control_high = node->InputAt(4);
           high_node = graph()->NewNode(store_op, base, index_high,
                                        GetReplacementHigh(value), effect_high,
                                        control_high);
           node->ReplaceInput(3, high_node);
 
@@ skipping 647 matching lines @@
                     common()->Phi(MachineRepresentation::kWord32, value_count),
                     value_count + 1, inputs_low, false),
                 graph()->NewNode(
                     common()->Phi(MachineRepresentation::kWord32, value_count),
                     value_count + 1, inputs_high, false));
   }
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8