[turbofan] Relax limitation for using BaseWithIndexAndDisplacement for load/stores

src/compiler/node.cc

 // Copyright 2013 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/node.h"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
@@ skipping 278 matching lines @@
       mask |= 1;
     } else if (from == owner2) {
       mask |= 2;
     } else {
       return false;
     }
   }
   return mask == 3;
 }
 
+bool Node::OwnedByAddressingOperand() const {
+  for (Use* use = first_use_; use; use = use->next) {
+    Node* from = use->from();
+    if (from->opcode() != IrOpcode::kLoad &&
+        from->opcode() != IrOpcode::kStore &&

[danno, 2017/02/21 16:11:01]

Careful here, don't you have to make sure that the input is the store address
and not the store value? If it's the latter, then it is not owned by just by
addressing operand.

[shiyu.zhang, 2017/02/23 01:20:48]

OwnedByAddressingOperand is only used by left operand ( InputAt(0) ) and right
operand ( InputAt(1) ) . For store node, InputAt(0) and InputAt(1) are base and
index, InputAt(2) is value. So there is no need to check here, right?

[danno, 2017/02/23 08:49:34]

Well, this builds in a pretty explicit and fragile assumption that
OwnedByAddressingOperand is only used by the scaled matcher. I would prefer if
it were possible to make it more robust, including with unit tests of the
function that ensure it only returns true in the cases that it's supposed to,
regardless of how careful the caller is.

+        from->opcode() != IrOpcode::kInt32Add &&
+        from->opcode() != IrOpcode::kInt64Add) {
+      return false;
+    }
+  }
+  return true;
+}
 
 void Node::Print() const {
   OFStream os(stdout);
   os << *this << std::endl;
   for (Node* input : this->inputs()) {
     os << "  " << *input << std::endl;
   }
 }
 
 std::ostream& operator<<(std::ostream& os, const Node& n) {
@@ skipping 117 matching lines @@
   ++(*this);
   return result;
 }
 
 
 bool Node::Uses::empty() const { return begin() == end(); }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8