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 108 matching lines @@
         } 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::kUnalignedLoad: {

[titzer, 2016/03/29 08:42:48]

Can you factor out the common code between load/unaligned_load and
store/unaligned_store?

+      UnalignedLoadRepresentation load_rep =
+          UnalignedLoadRepresentationOf(node->op());
+
+      if (load_rep.representation() == 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()->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) {
         // 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);
@@ skipping 24 matching lines @@
         }
 
         node->ReplaceInput(2, GetReplacementLow(value));
         NodeProperties::ChangeOp(node, store_op);
         ReplaceNode(node, node, high_node);
       } else {
         DefaultLowering(node);
       }
       break;
     }
+    case IrOpcode::kUnalignedStore: {
+      UnalignedStoreRepresentation store_rep =
+          UnalignedStoreRepresentationOf(node->op());
+      if (store_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)));
+
+        Node* value = node->InputAt(2);
+        DCHECK(HasReplacementLow(value));
+        DCHECK(HasReplacementHigh(value));
+
+        const Operator* 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);
+
+        } else {
+          high_node = graph()->NewNode(store_op, base, index_high,
+                                       GetReplacementHigh(value));
+        }
+
+        node->ReplaceInput(2, GetReplacementLow(value));
+        NodeProperties::ChangeOp(node, store_op);
+        ReplaceNode(node, node, high_node);
+      } else {
+        DefaultLowering(node);
+      }
+      break;
+    }
+
     case IrOpcode::kStart: {
       int parameter_count = GetParameterCountAfterLowering(signature());
       // Only exchange the node if the parameter count actually changed.
       if (parameter_count != signature()->parameter_count()) {
         int delta =
             parameter_count - static_cast<int>(signature()->parameter_count());
         int new_output_count = node->op()->ValueOutputCount() + delta;
         NodeProperties::ChangeOp(node, common()->Start(new_output_count));
       }
       break;
@@ skipping 456 matching lines @@
 }
 
 Node* Int64Lowering::GetReplacementHigh(Node* node) {
   Node* result = replacements_[node->id()].high;
   DCHECK(result);
   return result;
 }
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8