[deoptimizer] Basic support inlining based on SharedFunctionInfo.

src/compiler/js-typed-lowering.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/code-factory.h"
 #include "src/compiler/access-builder.h"
 #include "src/compiler/js-graph.h"
 #include "src/compiler/js-typed-lowering.h"
 #include "src/compiler/linkage.h"
 #include "src/compiler/node-matchers.h"
@@ skipping 244 matching lines @@
     if (state_info.state_combine().kind() == OutputFrameStateCombine::kPokeAt &&
         state_info.state_combine().GetOffsetToPokeAt() == 1) {
       return frame_state;
     }
 
     // Here, we smash the result of the conversion into the slot just below
     // the stack top. This is the slot that full code uses to store the
     // left operand.
     const Operator* op = jsgraph()->common()->FrameState(
         state_info.type(), state_info.bailout_id(),
-        OutputFrameStateCombine::PokeAt(1));
+        OutputFrameStateCombine::PokeAt(1), state_info.shared_info());
 
     return graph()->NewNode(op,
                             frame_state->InputAt(kFrameStateParametersInput),
                             frame_state->InputAt(kFrameStateLocalsInput),
                             frame_state->InputAt(kFrameStateStackInput),
                             frame_state->InputAt(kFrameStateContextInput),
                             frame_state->InputAt(kFrameStateFunctionInput),
                             frame_state->InputAt(kFrameStateOuterStateInput));
   }
 
   Node* CreateFrameStateForRightInput(Node* frame_state, Node* converted_left) {
     FrameStateCallInfo state_info =
         OpParameter<FrameStateCallInfo>(frame_state);
 
     if (state_info.bailout_id() == BailoutId::None()) {
       // Dummy frame state => just leave it as is.
       return frame_state;
     }
 
     // Create a frame state that stores the result of the operation to the
     // top of the stack (i.e., the slot used for the right operand).
     const Operator* op = jsgraph()->common()->FrameState(
         state_info.type(), state_info.bailout_id(),
-        OutputFrameStateCombine::PokeAt(0));
+        OutputFrameStateCombine::PokeAt(0), state_info.shared_info());
 
     // Change the left operand {converted_left} on the expression stack.
     Node* stack = frame_state->InputAt(2);
     DCHECK_EQ(stack->opcode(), IrOpcode::kStateValues);
     DCHECK_GE(stack->InputCount(), 2);
 
     // TODO(jarin) Allocate in a local zone or a reusable buffer.
     NodeVector new_values(stack->InputCount(), zone());
     for (int i = 0; i < stack->InputCount(); i++) {
       if (i == stack->InputCount() - 2) {
@@ skipping 1312 matching lines @@
 }
 
 
 MachineOperatorBuilder* JSTypedLowering::machine() const {
   return jsgraph()->machine();
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8