[deoptimizer] Basic support inlining based on SharedFunctionInfo.

src/frames.cc

 // Copyright 2012 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/frames.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 845 matching lines @@
   PrintF("\nfunction: ");
   function_->shared()->DebugName()->ShortPrint();
   PrintF("\ncode: ");
   code_->ShortPrint();
   if (code_->kind() == Code::FUNCTION) PrintF(" NON-OPT");
   if (code_->kind() == Code::OPTIMIZED_FUNCTION) PrintF(" OPT");
   PrintF("\npc: %d\n", offset_);
 }
 
 
-JSFunction* OptimizedFrame::LiteralAt(FixedArray* literal_array,
-                                      int literal_id) {
-  if (literal_id == Translation::kSelfLiteralId) {
-    return function();
-  }
-
-  return JSFunction::cast(literal_array->get(literal_id));
-}
-
-
 void OptimizedFrame::Summarize(List<FrameSummary>* frames) {
   DCHECK(frames->length() == 0);
   DCHECK(is_optimized());
 
   // Delegate to JS frame in absence of turbofan deoptimization.
   // TODO(turbofan): Revisit once we support deoptimization across the board.
   if (LookupCode()->is_turbofanned() && function()->shared()->asm_function() &&
       !FLAG_turbo_asm_deoptimization) {
     return JavaScriptFrame::Summarize(frames);
   }
 
   // We create the summary in reverse order because the frames
   // in the deoptimization translation are ordered bottom-to-top.
   DisallowHeapAllocation no_gc;
   TranslatedState state(this);
   bool is_constructor = IsConstructor();
   for (TranslatedFrame const& frame : state) {
     switch (frame.kind()) {
       case TranslatedFrame::kFunction: {
         BailoutId const ast_id = frame.node_id();
-        JSFunction* const function = frame.raw_function();
+
+        // Get the correct function in the optimized frame.
+        JSFunction* function = JSFunction::cast(frame[0].GetRawValue());
 
         // Get the correct receiver in the optimized frame.
-        Object* receiver = frame.front().GetRawValue();
+        Object* receiver = frame[1].GetRawValue();
         if (receiver == isolate()->heap()->arguments_marker()) {
           // TODO(jarin): Materializing a captured object (or duplicated
           // object) is hard, we return undefined for now. This breaks the
           // produced stack trace, as constructor frames aren't marked as
           // such anymore.
           receiver = isolate()->heap()->undefined_value();
         }
 
         Code* code = function->shared()->code();
         DeoptimizationOutputData* output_data =
@@ skipping 75 matching lines @@
   // TODO(turbofan): Revisit once we support deoptimization across the board.
   if (LookupCode()->is_turbofanned() && function()->shared()->asm_function() &&
       !FLAG_turbo_asm_deoptimization) {
     return JavaScriptFrame::GetFunctions(functions);
   }
 
   DisallowHeapAllocation no_gc;
   TranslatedState state(this);
   for (TranslatedFrame const& frame : state) {
     if (frame.kind() == TranslatedFrame::kFunction) {
-      functions->Add(frame.raw_function());
+      functions->Add(JSFunction::cast(frame[0].GetRawValue()));
     }
   }
 }
 
 
 int ArgumentsAdaptorFrame::GetNumberOfIncomingArguments() const {
   return Smi::cast(GetExpression(0))->value();
 }
 
 
@@ skipping 434 matching lines @@
   for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
     StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
     list.Add(frame, zone);
   }
   return list.ToVector();
 }
 
 
 }  // namespace internal
 }  // namespace v8