Add deoptimization translations.

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 405 matching lines @@
     case BasicBlockData::kReturn: {
       // If the result itself is a return, return its input.
       Node* value = (input != NULL && input->opcode() == IrOpcode::kReturn)
                         ? input->InputAt(0)
                         : input;
       return VisitReturn(value);
     }
     case BasicBlockData::kThrow:
       return VisitThrow(input);
     case BasicBlockData::kDeoptimize:
-      return VisitDeoptimization(input);
+      return VisitDeoptimize(input);
     case BasicBlockData::kCall: {
       BasicBlock* deoptimization = block->SuccessorAt(0);
       BasicBlock* continuation = block->SuccessorAt(1);
       VisitCall(input, continuation, deoptimization);
       break;
     }
     case BasicBlockData::kNone: {
       // TODO(titzer): exit block doesn't have control.
       DCHECK(input == NULL);
       break;
@@ skipping 46 matching lines @@
       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);
     case IrOpcode::kCall:
       return VisitCall(node, NULL, NULL);
     case IrOpcode::kFrameState:
-      // TODO(titzer): state nodes should be combined into their users.
+    case IrOpcode::kStateValues:
       return;
     case IrOpcode::kLoad: {
       MachineRepresentation load_rep = OpParameter<MachineRepresentation>(node);
       MarkAsRepresentation(load_rep, node);
       return VisitLoad(node);
     }
     case IrOpcode::kStore:
       return VisitStore(node);
     case IrOpcode::kWord32And:
       return VisitWord32And(node);
@@ skipping 442 matching lines @@
     Emit(kArchRet, NULL);
   }
 }
 
 
 void InstructionSelector::VisitThrow(Node* value) {
   UNIMPLEMENTED();  // TODO(titzer)
 }
 
 
-void InstructionSelector::VisitDeoptimization(Node* deopt) {
+static InstructionOperand* UseOrImmediate(OperandGenerator* g, Node* input) {
+  switch (input->opcode()) {
+    case IrOpcode::kInt32Constant:
+    case IrOpcode::kNumberConstant:
+    case IrOpcode::kFloat64Constant:
+    case IrOpcode::kHeapConstant:
+      return g->UseImmediate(input);
+    default:
+      return g->Use(input);
+  }
+}
+
+
+void InstructionSelector::VisitDeoptimize(Node* deopt) {
   DCHECK(deopt->op()->opcode() == IrOpcode::kDeoptimize);
   Node* state = deopt->InputAt(0);
   DCHECK(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).
+  BailoutId ast_id = OpParameter<BailoutId>(state);
+
+  // Add the inputs.
+  Node* parameters = state->InputAt(0);
+  int parameters_count = OpParameter<int>(parameters);
+
+  Node* locals = state->InputAt(1);
+  int locals_count = OpParameter<int>(locals);
+
+  Node* stack = state->InputAt(2);
+  int stack_count = OpParameter<int>(stack);
+
+  OperandGenerator g(this);
+  std::vector<InstructionOperand*> inputs;
+  inputs.reserve(parameters_count + locals_count + stack_count);
+  for (int i = 0; i < parameters_count; i++) {
+    inputs.push_back(UseOrImmediate(&g, parameters->InputAt(i)));
+  }
+  for (int i = 0; i < locals_count; i++) {
+    inputs.push_back(UseOrImmediate(&g, locals->InputAt(i)));
+  }
+  for (int i = 0; i < stack_count; i++) {
+    inputs.push_back(UseOrImmediate(&g, stack->InputAt(i)));
+  }
+
+  FrameStateDescriptor* descriptor = new (instruction_zone())
+      FrameStateDescriptor(ast_id, parameters_count, locals_count, stack_count);
+
+  DCHECK_EQ(descriptor->size(), inputs.size());
+
   int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
-  Emit(kArchDeoptimize | MiscField::encode(deoptimization_id), NULL);
+  Emit(kArchDeoptimize | MiscField::encode(deoptimization_id), 0, NULL,
+       inputs.size(), &inputs.front(), 0, NULL);
 }
 
 
 #if !V8_TURBOFAN_BACKEND
 
 #define DECLARE_UNIMPLEMENTED_SELECTOR(x) \
   void InstructionSelector::Visit##x(Node* node) { UNIMPLEMENTED(); }
 MACHINE_OP_LIST(DECLARE_UNIMPLEMENTED_SELECTOR)
 #undef DECLARE_UNIMPLEMENTED_SELECTOR
 
@@ skipping 28 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8