[turbofan] Add FixedArray peephole optimizations to CodeStubAssembler

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 69 matching lines @@
 }
 
 bool CodeAssembler::IsFloat64RoundDownSupported() const {
   return raw_assembler_->machine()->Float64RoundDown().IsSupported();
 }
 
 bool CodeAssembler::IsFloat64RoundTruncateSupported() const {
   return raw_assembler_->machine()->Float64RoundTruncate().IsSupported();
 }
 
-Node* CodeAssembler::Int32Constant(int value) {
+Node* CodeAssembler::Int32Constant(int32_t value) {
   return raw_assembler_->Int32Constant(value);
 }
 
+Node* CodeAssembler::Int64Constant(int64_t value) {
+  return raw_assembler_->Int64Constant(value);
+}
+
 Node* CodeAssembler::IntPtrConstant(intptr_t value) {
   return raw_assembler_->IntPtrConstant(value);
 }
 
 Node* CodeAssembler::NumberConstant(double value) {
   return raw_assembler_->NumberConstant(value);
 }
 
 Node* CodeAssembler::SmiConstant(Smi* value) {
   return IntPtrConstant(bit_cast<intptr_t>(value));
@@ skipping 12 matching lines @@
 }
 
 Node* CodeAssembler::Float64Constant(double value) {
   return raw_assembler_->Float64Constant(value);
 }
 
 Node* CodeAssembler::NaNConstant() {
   return LoadRoot(Heap::kNanValueRootIndex);
 }
 
+bool CodeAssembler::ToInt32Constant(Node* node, int32_t& out_value) {
+  if (node->opcode() == IrOpcode::kInt32Constant) {

[Michael Starzinger, 2016/05/19 10:54:21]

Can we use an Int32Matcher to do this kind of matching?

[danno, 2016/05/19 11:10:18]

Done.

+    out_value = OpParameter<int32_t>(node);
+    return true;
+  }
+
+  if (node->opcode() == IrOpcode::kInt64Constant) {

[Michael Starzinger, 2016/05/19 10:54:21]

Can we use an Int64Matcher (and the IsInRange method) here?

[danno, 2016/05/19 11:10:18]

Done.

+    int64_t big_value = OpParameter<int64_t>(node);
+    if (big_value <= std::numeric_limits<int32_t>::max() &&
+        big_value >= std::numeric_limits<int32_t>::min()) {
+      out_value = static_cast<int32_t>(big_value);
+      return true;
+    }
+  }
+
+  return false;
+}
+
+bool CodeAssembler::ToInt64Constant(Node* node, int64_t& out_value) {
+  if (node->opcode() == IrOpcode::kInt32Constant) {

[Michael Starzinger, 2016/05/19 10:54:21]

Can we use an Int64Matcher to do this kind of matching?

Int64Matcher m(node);
if (m.HasValue()) out_value = m.Value();
return m.HasValue();

[danno, 2016/05/19 11:10:18]

Done.

+    out_value = OpParameter<int32_t>(node);
+    return true;
+  }
+  if (node->opcode() == IrOpcode::kInt64Constant) {
+    out_value = OpParameter<int64_t>(node);
+    return true;
+  }
+  return false;
+}
+
+bool CodeAssembler::ToIntPtrConstant(Node* node, intptr_t& out_value) {
+  if (kPointerSize == 8) {

[Michael Starzinger, 2016/05/19 10:54:21]

Can we use an IntPtrMatcher to do this kind of matching?

[danno, 2016/05/19 11:10:18]

Done.

+    if (node->opcode() == IrOpcode::kInt64Constant) {
+      out_value = OpParameter<intptr_t>(node);
+      return true;
+    }
+  } else {
+    DCHECK_EQ(4, kPointerSize);
+    if (node->opcode() == IrOpcode::kInt32Constant) {
+      out_value = OpParameter<intptr_t>(node);
+      return true;
+    }
+  }
+  return false;
+}
+
 Node* CodeAssembler::Parameter(int value) {
   return raw_assembler_->Parameter(value);
 }
 
 void CodeAssembler::Return(Node* value) {
   return raw_assembler_->Return(value);
 }
 
 void CodeAssembler::Bind(CodeAssembler::Label* label) { return label->Bind(); }
 
@@ skipping 563 matching lines @@
       }
     }
   }
 
   bound_ = true;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8