[turbofan] Add Int32AddWithOverflow machine operator.

src/compiler/instruction-selector.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/instruction-selector.h"
 
 #include "src/compiler/instruction-selector-impl.h"
 #include "src/compiler/node-matchers.h"
 #include "src/compiler/node-properties-inl.h"
 #include "src/compiler/pipeline.h"
@@ skipping 234 matching lines @@
                                                BasicBlock* deopt_node) {
   OperandGenerator g(this);
   ASSERT_EQ(call->op()->OutputCount(), buffer->descriptor->ReturnCount());
   ASSERT_EQ(NodeProperties::GetValueInputCount(call), buffer->input_count());
 
   if (buffer->descriptor->ReturnCount() > 0) {
     // Collect the projections that represent multiple outputs from this call.
     if (buffer->descriptor->ReturnCount() == 1) {
       buffer->output_nodes[0] = call;
     } else {
-      // Iterate over all uses of {call} and collect the projections into the
-      // {result} buffer.
-      for (UseIter i = call->uses().begin(); i != call->uses().end(); ++i) {
-        if ((*i)->opcode() == IrOpcode::kProjection) {
-          int index = OpParameter<int32_t>(*i);
-          ASSERT_GE(index, 0);
-          ASSERT_LT(index, buffer->descriptor->ReturnCount());
-          ASSERT_EQ(NULL, buffer->output_nodes[index]);
-          buffer->output_nodes[index] = *i;
-        }
-      }
+      call->CollectProjections(buffer->descriptor->ReturnCount(),
+                               buffer->output_nodes);
     }
 
     // Filter out the outputs that aren't live because no projection uses them.
     for (int i = 0; i < buffer->descriptor->ReturnCount(); i++) {
       if (buffer->output_nodes[i] != NULL) {
         Node* output = buffer->output_nodes[i];
         LinkageLocation location = buffer->descriptor->GetReturnLocation(i);
         MarkAsRepresentation(location.representation(), output);
         buffer->outputs[buffer->output_count++] =
             g.DefineAsLocation(output, location);
@@ skipping 164 matching lines @@
   }
   switch (node->opcode()) {
     case IrOpcode::kStart:
     case IrOpcode::kLoop:
     case IrOpcode::kEnd:
     case IrOpcode::kBranch:
     case IrOpcode::kIfTrue:
     case IrOpcode::kIfFalse:
     case IrOpcode::kEffectPhi:
     case IrOpcode::kMerge:
-    case IrOpcode::kProjection:
     case IrOpcode::kLazyDeoptimization:
     case IrOpcode::kContinuation:
       // No code needed for these graph artifacts.
       return;
-    case IrOpcode::kPhi:
-      return VisitPhi(node);
     case IrOpcode::kParameter: {
       int index = OpParameter<int>(node);
       MachineRepresentation rep = linkage()
                                       ->GetIncomingDescriptor()
                                       ->GetInputLocation(index)
                                       .representation();
       MarkAsRepresentation(rep, node);
       return VisitParameter(node);
     }
+    case IrOpcode::kPhi:
+      return VisitPhi(node);
+    case IrOpcode::kProjection:
+      return VisitProjection(node);
     case IrOpcode::kInt32Constant:
     case IrOpcode::kInt64Constant:
     case IrOpcode::kExternalConstant:
       return VisitConstant(node);
     case IrOpcode::kFloat64Constant:
       return MarkAsDouble(node), VisitConstant(node);
     case IrOpcode::kHeapConstant:
     case IrOpcode::kNumberConstant:
       // TODO(turbofan): only mark non-smis as references.
       return MarkAsReference(node), VisitConstant(node);
@@ skipping 32 matching lines @@
     case IrOpcode::kWord64Shl:
       return VisitWord64Shl(node);
     case IrOpcode::kWord64Shr:
       return VisitWord64Shr(node);
     case IrOpcode::kWord64Sar:
       return VisitWord64Sar(node);
     case IrOpcode::kWord64Equal:
       return VisitWord64Equal(node);
     case IrOpcode::kInt32Add:
       return VisitInt32Add(node);
+    case IrOpcode::kInt32AddWithOverflow:
+      return VisitInt32AddWithOverflow(node);
     case IrOpcode::kInt32Sub:
       return VisitInt32Sub(node);
     case IrOpcode::kInt32Mul:
       return VisitInt32Mul(node);
     case IrOpcode::kInt32Div:
       return VisitInt32Div(node);
     case IrOpcode::kInt32UDiv:
       return VisitInt32UDiv(node);
     case IrOpcode::kInt32Mod:
       return VisitInt32Mod(node);
@@ skipping 201 matching lines @@
 
 
 void InstructionSelector::VisitWord64Compare(Node* node,
                                              FlagsContinuation* cont) {
   UNIMPLEMENTED();
 }
 
 #endif  // V8_TARGET_ARCH_32_BIT || !V8_TURBOFAN_TARGET
 
 
+void InstructionSelector::VisitParameter(Node* node) {
+  OperandGenerator g(this);
+  Emit(kArchNop, g.DefineAsLocation(node, linkage()->GetParameterLocation(
+                                              OpParameter<int>(node))));
+}
+
+
 void InstructionSelector::VisitPhi(Node* node) {
   // TODO(bmeurer): Emit a PhiInstruction here.
   for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
     MarkAsUsed(*i);
   }
 }
 
 
-void InstructionSelector::VisitParameter(Node* node) {
-  OperandGenerator g(this);
-  Emit(kArchNop, g.DefineAsLocation(node, linkage()->GetParameterLocation(
-                                              OpParameter<int>(node))));
+void InstructionSelector::VisitProjection(Node* node) {
+  for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
+    MarkAsUsed(*i);
+  }
 }
 
 
 void InstructionSelector::VisitConstant(Node* node) {
   // We must emit a NOP here because every live range needs a defining
   // instruction in the register allocator.
   OperandGenerator g(this);
   Emit(kArchNop, g.DefineAsConstant(node));
 }
 
@@ skipping 147 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8