[turbofan] Add support for Finish to the InstructionSelector.

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 181 matching lines @@
   DCHECK_NOT_NULL(node);
   return sequence()->IsDouble(node->id());
 }
 
 
 void InstructionSelector::MarkAsDouble(Node* node) {
   DCHECK_NOT_NULL(node);
   DCHECK(!IsReference(node));
   sequence()->MarkAsDouble(node->id());
 
-  // Propagate "doubleness" throughout phis.
+  // Propagate "doubleness" throughout Finish/Phi nodes.
   for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
     Node* user = *i;
-    if (user->opcode() != IrOpcode::kPhi) continue;
-    if (IsDouble(user)) continue;
-    MarkAsDouble(user);
+    switch (user->opcode()) {
+      case IrOpcode::kFinish:
+      case IrOpcode::kPhi:
+        if (IsDouble(user)) continue;
+        MarkAsDouble(user);
+        break;
+      default:
+        break;
+    }
   }
 }
 
 
 bool InstructionSelector::IsReference(const Node* node) const {
   DCHECK_NOT_NULL(node);
   return sequence()->IsReference(node->id());
 }
 
 
 void InstructionSelector::MarkAsReference(Node* node) {
   DCHECK_NOT_NULL(node);
   DCHECK(!IsDouble(node));
   sequence()->MarkAsReference(node->id());
 
-  // Propagate "referenceness" throughout phis.
+  // Propagate "referenceness" throughout Finish/Phi nodes.
   for (UseIter i = node->uses().begin(); i != node->uses().end(); ++i) {
     Node* user = *i;
-    if (user->opcode() != IrOpcode::kPhi) continue;
-    if (IsReference(user)) continue;
-    MarkAsReference(user);
+    switch (user->opcode()) {
+      case IrOpcode::kFinish:
+      case IrOpcode::kPhi:
+        if (IsReference(user)) continue;
+        MarkAsReference(user);
+        break;
+      default:
+        break;
+    }
   }
 }
 
 
 void InstructionSelector::MarkAsRepresentation(MachineType rep, Node* node) {
   DCHECK_NOT_NULL(node);
   if (RepresentationOf(rep) == kRepFloat64) MarkAsDouble(node);
   if (RepresentationOf(rep) == kRepTagged) MarkAsReference(node);
 }
 
@@ skipping 218 matching lines @@
     case IrOpcode::kEnd:
     case IrOpcode::kBranch:
     case IrOpcode::kIfTrue:
     case IrOpcode::kIfFalse:
     case IrOpcode::kEffectPhi:
     case IrOpcode::kMerge:
     case IrOpcode::kLazyDeoptimization:
     case IrOpcode::kContinuation:
       // No code needed for these graph artifacts.
       return;
+    case IrOpcode::kFinish:
+      return VisitFinish(node);
     case IrOpcode::kParameter: {
-      int index = OpParameter<int>(node);
-      MachineType rep = linkage()
-                            ->GetIncomingDescriptor()
-                            ->GetInputLocation(index)
-                            .representation();
-      MarkAsRepresentation(rep, node);
+      LinkageLocation location =
+          linkage()->GetParameterLocation(OpParameter<int>(node));
+      MarkAsRepresentation(location.representation(), 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);
@@ skipping 306 matching lines @@
 
 
 void InstructionSelector::VisitWord64Compare(Node* node,
                                              FlagsContinuation* cont) {
   UNIMPLEMENTED();
 }
 
 #endif  // V8_TARGET_ARCH_32_BIT || !V8_TURBOFAN_BACKEND
 
 
+void InstructionSelector::VisitFinish(Node* node) {
+  OperandGenerator g(this);
+  Node* value = node->InputAt(0);
+  Emit(kArchNop, g.DefineSameAsFirst(node), g.Use(value));
+}
+
+
 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) {
@@ skipping 257 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8