Removal of the deoptimization block from Turbofan

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 253 matching lines @@
                        FrameStateDescriptor* frame_desc)
     : descriptor(d),
       frame_state_descriptor(frame_desc),
       output_nodes(zone),
       outputs(zone),
       instruction_args(zone),
       pushed_nodes(zone) {
   output_nodes.reserve(d->ReturnCount());
   outputs.reserve(d->ReturnCount());
   pushed_nodes.reserve(input_count());
-  instruction_args.reserve(input_count() + control_count() +
-                           frame_state_value_count());
+  instruction_args.reserve(input_count() + frame_state_value_count());
 }
 
 
 // TODO(bmeurer): Get rid of the CallBuffer business and make
 // InstructionSelector::VisitCall platform independent instead.
 void InstructionSelector::InitializeCallBuffer(Node* call, CallBuffer* buffer,
                                                bool call_code_immediate,
-                                               bool call_address_immediate,
-                                               BasicBlock* cont_node,
-                                               BasicBlock* deopt_node) {
+                                               bool call_address_immediate) {
   OperandGenerator g(this);
   DCHECK_EQ(call->op()->OutputCount(), buffer->descriptor->ReturnCount());
   DCHECK_EQ(OperatorProperties::GetValueInputCount(call->op()),
             buffer->input_count() + buffer->frame_state_count());
 
   if (buffer->descriptor->ReturnCount() > 0) {
     // Collect the projections that represent multiple outputs from this call.
     if (buffer->descriptor->ReturnCount() == 1) {
       buffer->output_nodes.push_back(call);
     } else {
@@ skipping 35 matching lines @@
           g.UseLocation(callee, buffer->descriptor->GetInputLocation(0)));
       break;
   }
   DCHECK_EQ(1, buffer->instruction_args.size());
 
   // If the call needs a frame state, we insert the state information as
   // follows (n is the number of value inputs to the frame state):
   // arg 1               : deoptimization id.
   // arg 2 - arg (n + 1) : value inputs to the frame state.
   if (buffer->frame_state_descriptor != NULL) {
-    int deoptimization_id =
-        sequence()->AddDeoptimizationEntry(buffer->frame_state_descriptor);
-    buffer->instruction_args.push_back(g.TempImmediate(deoptimization_id));
+    InstructionSequence::StateId state_id =
+        sequence()->AddFrameStateDescriptor(buffer->frame_state_descriptor);
+    buffer->instruction_args.push_back(g.TempImmediate(state_id.ToInt()));
 
     Node* frame_state = call->InputAt(buffer->descriptor->InputCount());
     AddFrameStateInputs(frame_state, &buffer->instruction_args,
                         buffer->frame_state_descriptor);
   }
   DCHECK_EQ(1 + buffer->frame_state_value_count(),
             buffer->instruction_args.size());
 
   int input_count = buffer->input_count();
 
@@ skipping 16 matching lines @@
         buffer->pushed_nodes.resize(stack_index + 1, NULL);
       }
       DCHECK_EQ(NULL, buffer->pushed_nodes[stack_index]);
       buffer->pushed_nodes[stack_index] = *iter;
       pushed_count++;
     } else {
       buffer->instruction_args.push_back(op);
     }
   }
   CHECK_EQ(pushed_count, static_cast<int>(buffer->pushed_nodes.size()));
-
-  // If the call can deoptimize, we add the continuation and deoptimization
-  // block labels.
-  if (buffer->descriptor->CanLazilyDeoptimize()) {
-    DCHECK(cont_node != NULL);
-    DCHECK(deopt_node != NULL);
-    buffer->instruction_args.push_back(g.Label(cont_node));
-    buffer->instruction_args.push_back(g.Label(deopt_node));
-  } else {
-    DCHECK(cont_node == NULL);
-    DCHECK(deopt_node == NULL);
-  }
-
   DCHECK(static_cast<size_t>(input_count) ==
-         (buffer->instruction_args.size() - buffer->control_count() +
-          buffer->pushed_nodes.size() - buffer->frame_state_value_count()));
+         (buffer->instruction_args.size() + buffer->pushed_nodes.size() -
+          buffer->frame_state_value_count()));
 }
 
 
 void InstructionSelector::VisitBlock(BasicBlock* block) {
   DCHECK_EQ(NULL, current_block_);
   current_block_ = block;
   int current_block_end = static_cast<int>(instructions_.size());
 
   // Generate code for the block control "top down", but schedule the code
   // "bottom up".
@@ skipping 52 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 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;
     }
     default:
       UNREACHABLE();
       break;
   }
 }
@@ skipping 10 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::kLazyDeoptimization:
-    case IrOpcode::kContinuation:
       // No code needed for these graph artifacts.
       return;
     case IrOpcode::kFinish:
       return VisitFinish(node);
     case IrOpcode::kParameter: {
       LinkageLocation location =
           linkage()->GetParameterLocation(OpParameter<int>(node));
       MarkAsRepresentation(location.representation(), node);
       return VisitParameter(node);
     }
@@ skipping 503 matching lines @@
 
 
 void InstructionSelector::VisitThrow(Node* value) {
   UNIMPLEMENTED();  // TODO(titzer)
 }
 
 
 FrameStateDescriptor* InstructionSelector::GetFrameStateDescriptor(
     Node* state) {
   DCHECK(state->op()->opcode() == IrOpcode::kFrameState);
-  BailoutId ast_id = OpParameter<BailoutId>(state);
+  FrameStateCallInfo state_info = OpParameter<FrameStateCallInfo>(state);
   Node* parameters = state->InputAt(0);
   Node* locals = state->InputAt(1);
   Node* stack = state->InputAt(2);
 
   return new (instruction_zone())
-      FrameStateDescriptor(ast_id, OpParameter<int>(parameters),
+      FrameStateDescriptor(state_info, OpParameter<int>(parameters),
                            OpParameter<int>(locals), OpParameter<int>(stack));
 }
 
 
 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->UseUnique(input);
   }
 }
 
 
 void InstructionSelector::AddFrameStateInputs(
     Node* state, InstructionOperandVector* inputs,
     FrameStateDescriptor* descriptor) {
   DCHECK_EQ(IrOpcode::kFrameState, state->op()->opcode());
 
   Node* parameters = state->InputAt(0);
   Node* locals = state->InputAt(1);
   Node* stack = state->InputAt(2);
+  Node* context = state->InputAt(3);
+
+  DCHECK_EQ(IrOpcode::kStateValues, parameters->op()->opcode());
+  DCHECK_EQ(IrOpcode::kStateValues, locals->op()->opcode());
+  DCHECK_EQ(IrOpcode::kStateValues, stack->op()->opcode());
 
   DCHECK_EQ(descriptor->parameters_count(), parameters->InputCount());
   DCHECK_EQ(descriptor->locals_count(), locals->InputCount());
   DCHECK_EQ(descriptor->stack_count(), stack->InputCount());
 
   OperandGenerator g(this);
   for (int i = 0; i < descriptor->parameters_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, parameters->InputAt(i)));
   }
+  inputs->push_back(UseOrImmediate(&g, context));
   for (int i = 0; i < descriptor->locals_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, locals->InputAt(i)));
   }
   for (int i = 0; i < descriptor->stack_count(); i++) {
     inputs->push_back(UseOrImmediate(&g, stack->InputAt(i)));
   }
 }
 
 
-void InstructionSelector::VisitDeoptimize(Node* deopt) {
-  DCHECK(deopt->op()->opcode() == IrOpcode::kDeoptimize);
-  Node* state = deopt->InputAt(0);
-  FrameStateDescriptor* descriptor = GetFrameStateDescriptor(state);
-  int deoptimization_id = sequence()->AddDeoptimizationEntry(descriptor);
-
-  InstructionOperandVector inputs(zone());
-  inputs.reserve(descriptor->size() + 1);
-
-  OperandGenerator g(this);
-  inputs.push_back(g.TempImmediate(deoptimization_id));
-
-  AddFrameStateInputs(state, &inputs, descriptor);
-
-  DCHECK_EQ(descriptor->size() + 1, inputs.size());
-
-  Emit(kArchDeoptimize, 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
 
 
 void InstructionSelector::VisitInt32AddWithOverflow(Node* node,
                                                     FlagsContinuation* cont) {
@@ skipping 25 matching lines @@
 
 
 void InstructionSelector::VisitCall(Node* call, BasicBlock* continuation,
                                     BasicBlock* deoptimization) {}
 
 #endif  // !V8_TURBOFAN_BACKEND
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8