[csa] Re-introduce automatic constant folding for IntPtrAdd and IntPtrSub

src/compiler/code-assembler.cc

 // Copyright 2015 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/code-assembler.h"
 
 #include <ostream>
 
 #include "src/code-factory.h"
 #include "src/compiler/graph.h"
@@ skipping 191 matching lines @@
   }
   IntPtrMatcher m(node);
   if (m.HasValue()) {
     out_value = Smi::cast(bit_cast<Object*>(m.Value()));
     return true;
   }
   return false;
 }
 
 bool CodeAssembler::ToIntPtrConstant(Node* node, intptr_t& out_value) {
+  if (node->opcode() == IrOpcode::kBitcastWordToTaggedSigned ||
+      node->opcode() == IrOpcode::kBitcastWordToTagged) {
+    node = node->InputAt(0);
+  }
   IntPtrMatcher m(node);
   if (m.HasValue()) out_value = m.Value();
   return m.HasValue();
 }
 
 Node* CodeAssembler::Parameter(int value) {
   return raw_assembler()->Parameter(value);
 }
 
 void CodeAssembler::Return(Node* value) {
@@ skipping 40 matching lines @@
   return raw_assembler()->LoadStackPointer();
 }
 
 #define DEFINE_CODE_ASSEMBLER_BINARY_OP(name)   \
   Node* CodeAssembler::name(Node* a, Node* b) { \
     return raw_assembler()->name(a, b);         \
   }
 CODE_ASSEMBLER_BINARY_OP_LIST(DEFINE_CODE_ASSEMBLER_BINARY_OP)
 #undef DEFINE_CODE_ASSEMBLER_BINARY_OP
 
+Node* CodeAssembler::IntPtrAdd(Node* left, Node* right) {
+  intptr_t left_constant;
+  bool is_left_constant = ToIntPtrConstant(left, left_constant);
+  intptr_t right_constant;
+  bool is_right_constant = ToIntPtrConstant(right, right_constant);
+  if (is_left_constant) {
+    if (is_right_constant) {
+      intptr_t sum = left_constant + right_constant;
+      if (sum >= std::numeric_limits<int32_t>::min() &&

[Igor Sheludko, 2016/12/28 15:57:05]

I think we can always return the sum.

[danno, 2016/12/28 16:05:33]

Done.

+          sum <= std::numeric_limits<int32_t>::max()) {
+        return IntPtrConstant(sum);
+      }
+    }
+    if (left_constant == 0) {
+      return right;
+    }
+  } else if (is_right_constant) {
+    if (right_constant == 0) {
+      return left;
+    }
+  }
+  return raw_assembler()->IntPtrAdd(left, right);
+}
+
+Node* CodeAssembler::IntPtrSub(Node* left, Node* right) {
+  intptr_t left_constant;
+  bool is_left_constant = ToIntPtrConstant(left, left_constant);
+  intptr_t right_constant;
+  bool is_right_constant = ToIntPtrConstant(right, right_constant);
+  if (is_left_constant) {
+    if (is_right_constant) {
+      intptr_t diff = left_constant - right_constant;
+      if (diff >= std::numeric_limits<int32_t>::min() &&

[Igor Sheludko, 2016/12/28 15:57:05]

Same here.

[danno, 2016/12/28 16:05:33]

Done.

+          diff <= std::numeric_limits<int32_t>::max()) {
+        return IntPtrConstant(diff);
+      }
+    }
+  } else if (is_right_constant) {
+    if (right_constant == 0) {
+      return left;
+    }
+  }
+  return raw_assembler()->IntPtrSub(left, right);
+}
+
 Node* CodeAssembler::WordShl(Node* value, int shift) {
   return (shift != 0) ? raw_assembler()->WordShl(value, IntPtrConstant(shift))
                       : value;
 }
 
 Node* CodeAssembler::WordShr(Node* value, int shift) {
   return (shift != 0) ? raw_assembler()->WordShr(value, IntPtrConstant(shift))
                       : value;
 }
 
@@ skipping 472 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8