[turbofan] Support for combining branches with <Operation>WithOverflow.

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"
 
 namespace v8 {
 namespace internal {
 namespace compiler {
 
 InstructionSelector::InstructionSelector(InstructionSequence* sequence,
                                          SourcePositionTable* source_positions)
     : zone_(sequence->isolate()),
       sequence_(sequence),
       source_positions_(source_positions),
       current_block_(NULL),
       instructions_(InstructionDeque::allocator_type(zone())),
+      defined_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())),
       used_(graph()->NodeCount(), false, BoolVector::allocator_type(zone())) {}
 
 
 void InstructionSelector::SelectInstructions() {
   // Mark the inputs of all phis in loop headers as used.
   BasicBlockVector* blocks = schedule()->rpo_order();
   for (BasicBlockVectorIter i = blocks->begin(); i != blocks->end(); ++i) {
     BasicBlock* block = *i;
     if (!block->IsLoopHeader()) continue;
     ASSERT_NE(0, block->PredecessorCount());
@@ skipping 109 matching lines @@
          block->deferred_ == current_block_->deferred_;
 }
 
 
 bool InstructionSelector::CanCover(Node* user, Node* node) const {
   return node->OwnedBy(user) &&
          schedule()->block(node) == schedule()->block(user);
 }
 
 
+bool InstructionSelector::IsDefined(Node* node) const {
+  ASSERT_NOT_NULL(node);
+  NodeId id = node->id();
+  ASSERT(id >= 0);
+  ASSERT(id < static_cast<NodeId>(defined_.size()));
+  return defined_[id];
+}
+
+
+void InstructionSelector::MarkAsDefined(Node* node) {
+  ASSERT_NOT_NULL(node);
+  NodeId id = node->id();
+  ASSERT(id >= 0);
+  ASSERT(id < static_cast<NodeId>(defined_.size()));
+  defined_[id] = true;
+}
+
+
 bool InstructionSelector::IsUsed(Node* node) const {
   if (!node->op()->HasProperty(Operator::kEliminatable)) return true;
   NodeId id = node->id();
   ASSERT(id >= 0);
   ASSERT(id < static_cast<NodeId>(used_.size()));
   return used_[id];
 }
 
 
 void InstructionSelector::MarkAsUsed(Node* node) {
@@ skipping 178 matching lines @@
   // Generate code for the block control "top down", but schedule the code
   // "bottom up".
   VisitControl(block);
   std::reverse(instructions_.begin() + current_block_end, instructions_.end());
 
   // Visit code in reverse control flow order, because architecture-specific
   // matching may cover more than one node at a time.
   for (BasicBlock::reverse_iterator i = block->rbegin(); i != block->rend();
        ++i) {
     Node* node = *i;
-    if (!IsUsed(node)) continue;
+    // Skip nodes that are unused or already defined.
+    if (!IsUsed(node) || IsDefined(node)) continue;
     // Generate code for this node "top down", but schedule the code "bottom
     // up".
     size_t current_node_end = instructions_.size();
     VisitNode(node);
     std::reverse(instructions_.begin() + current_node_end, instructions_.end());
   }
 
   // We're done with the block.
   // TODO(bmeurer): We should not mutate the schedule.
   block->code_end_ = current_block_end;
@@ skipping 262 matching lines @@
 void InstructionSelector::VisitWord64Equal(Node* node) {
   FlagsContinuation cont(kEqual, node);
   Int64BinopMatcher m(node);
   if (m.right().Is(0)) {
     return VisitWord64Test(m.left().node(), &cont);
   }
   VisitWord64Compare(node, &cont);
 }
 
 
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node) {
+  if (Node* ovf = node->FindProjection(1)) {
+    FlagsContinuation cont(kOverflow, ovf);
+    return VisitInt32AddWithOverflow(node, &cont);
+  }
+  FlagsContinuation cont;
+  VisitInt32AddWithOverflow(node, &cont);
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node) {
+  if (Node* ovf = node->FindProjection(1)) {
+    FlagsContinuation cont(kOverflow, ovf);
+    return VisitInt32SubWithOverflow(node, &cont);
+  }
+  FlagsContinuation cont;
+  VisitInt32SubWithOverflow(node, &cont);
+}
+
+
 void InstructionSelector::VisitInt64LessThan(Node* node) {
   FlagsContinuation cont(kSignedLessThan, node);
   VisitWord64Compare(node, &cont);
 }
 
 
 void InstructionSelector::VisitInt64LessThanOrEqual(Node* node) {
   FlagsContinuation cont(kSignedLessThanOrEqual, node);
   VisitWord64Compare(node, &cont);
 }
@@ skipping 98 matching lines @@
 
 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::VisitProjection(Node* node) {
-  for (InputIter i = node->inputs().begin(); i != node->inputs().end(); ++i) {
-    MarkAsUsed(*i);
+  OperandGenerator g(this);
+  Node* value = node->InputAt(0);
+  switch (value->opcode()) {
+    case IrOpcode::kInt32AddWithOverflow:
+    case IrOpcode::kInt32SubWithOverflow:
+      if (OpParameter<int32_t>(node) == 0) {
+        Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
+      } else {
+        ASSERT_EQ(1, OpParameter<int32_t>(node));
+        MarkAsUsed(value);
+      }
+      break;
+    default:
+      break;
   }
 }
 
 
 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 79 matching lines @@
         return VisitWord64Compare(value, &cont);
       case IrOpcode::kFloat64Equal:
         cont.OverwriteAndNegateIfEqual(kUnorderedEqual);
         return VisitFloat64Compare(value, &cont);
       case IrOpcode::kFloat64LessThan:
         cont.OverwriteAndNegateIfEqual(kUnorderedLessThan);
         return VisitFloat64Compare(value, &cont);
       case IrOpcode::kFloat64LessThanOrEqual:
         cont.OverwriteAndNegateIfEqual(kUnorderedLessThanOrEqual);
         return VisitFloat64Compare(value, &cont);
+      case IrOpcode::kProjection:
+        // Check if this is the overflow output projection of an
+        // <Operation>WithOverflow node.
+        if (OpParameter<int32_t>(value) == 1) {
+          // We cannot combine the <Operation>WithOverflow with this branch
+          // unless the 0th projection (the use of the actual value of the
+          // <Operation> is either NULL, which means there's no use of the
+          // actual value, or was already defined, which means it is scheduled
+          // *AFTER* this branch).
+          Node* node = value->InputAt(0);
+          Node* result = node->FindProjection(0);
+          if (result == NULL || IsDefined(result)) {
+            switch (node->opcode()) {
+              case IrOpcode::kInt32AddWithOverflow:
+                cont.OverwriteAndNegateIfEqual(kOverflow);
+                return VisitInt32AddWithOverflow(node, &cont);
+              case IrOpcode::kInt32SubWithOverflow:
+                cont.OverwriteAndNegateIfEqual(kOverflow);
+                return VisitInt32SubWithOverflow(node, &cont);
+              default:
+                break;
+            }
+          }
+        }
+        break;
       default:
         break;
     }
   }
 
   // Branch could not be combined with a compare, emit compare against 0.
   VisitWord32Test(value, &cont);
 }
 
 
@@ skipping 16 matching lines @@
   ASSERT(deopt->op()->opcode() == IrOpcode::kDeoptimize);
   Node* state = deopt->InputAt(0);
   ASSERT(state->op()->opcode() == IrOpcode::kFrameState);
   FrameStateDescriptor descriptor = OpParameter<FrameStateDescriptor>(state);
   // TODO(jarin) We should also add an instruction input for every input to
   // the framestate node (and recurse for the inlined framestates).
   int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
   Emit(kArchDeoptimize | MiscField::encode(deoptimization_id), NULL);
 }
 
+
 #if !V8_TURBOFAN_TARGET
 
 #define DECLARE_UNIMPLEMENTED_SELECTOR(x) \
   void InstructionSelector::Visit##x(Node* node) { UNIMPLEMENTED(); }
 MACHINE_OP_LIST(DECLARE_UNIMPLEMENTED_SELECTOR)
 #undef DECLARE_UNIMPLEMENTED_SELECTOR
 
 
+void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
+                                                    FlagsContinuation* cont) {
+  UNIMPLEMENTED();
+}
+
+
+void InstructionSelector::VisitInt32SubWithOverflow(Node* node,
+                                                    FlagsContinuation* cont) {
+  UNIMPLEMENTED();
+}
+
+
 void InstructionSelector::VisitWord32Test(Node* node, FlagsContinuation* cont) {
   UNIMPLEMENTED();
 }
 
 
 void InstructionSelector::VisitWord32Compare(Node* node,
                                              FlagsContinuation* cont) {
   UNIMPLEMENTED();
 }
 
 
 void InstructionSelector::VisitFloat64Compare(Node* node,
                                               FlagsContinuation* cont) {
   UNIMPLEMENTED();
 }
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
-#endif
+#endif  // !V8_TURBOFAN_TARGET
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8