[deoptimizer] Basic support inlining based on SharedFunctionInfo.

src/deoptimizer.cc

 // Copyright 2013 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/v8.h"
 
 #include "src/accessors.h"
 #include "src/codegen.h"
 #include "src/cpu-profiler.h"
 #include "src/deoptimizer.h"
@@ skipping 814 matching lines @@
 
 
 void Deoptimizer::DoComputeJSFrame(TranslationIterator* iterator,
                                    int frame_index) {
   TranslatedFrame* translated_frame =
       &(translated_state_.frames()[frame_index]);
   TranslatedFrame::iterator value_iterator = translated_frame->begin();
   int input_index = 0;
 
   BailoutId node_id = translated_frame->node_id();
-  JSFunction* function = translated_frame->raw_function();
   unsigned height =
       translated_frame->height() - 1;  // Do not count the context.
   unsigned height_in_bytes = height * kPointerSize;
+  JSFunction* function = JSFunction::cast(value_iterator->GetRawValue());
+  value_iterator++;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(), "  translating frame ");
     function->PrintName(trace_scope_->file());
     PrintF(trace_scope_->file(),
            " => node=%d, height=%d\n", node_id.ToInt(), height_in_bytes);
   }
 
   // The 'fixed' part of the frame consists of the incoming parameters and
   // the part described by JavaScriptFrameConstants.
   unsigned fixed_frame_size = ComputeFixedSize(function);
@@ skipping 215 matching lines @@
 }
 
 
 void Deoptimizer::DoComputeArgumentsAdaptorFrame(TranslationIterator* iterator,
                                                  int frame_index) {
   TranslatedFrame* translated_frame =
       &(translated_state_.frames()[frame_index]);
   TranslatedFrame::iterator value_iterator = translated_frame->begin();
   int input_index = 0;
 
-  JSFunction* function = translated_frame->raw_function();
   unsigned height = translated_frame->height();
   unsigned height_in_bytes = height * kPointerSize;
+  JSFunction* function = JSFunction::cast(value_iterator->GetRawValue());
+  value_iterator++;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating arguments adaptor => height=%d\n", height_in_bytes);
   }
 
   unsigned fixed_frame_size = ArgumentsAdaptorFrameConstants::kFrameSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
@@ skipping 109 matching lines @@
 
 void Deoptimizer::DoComputeConstructStubFrame(TranslationIterator* iterator,
                                               int frame_index) {
   TranslatedFrame* translated_frame =
       &(translated_state_.frames()[frame_index]);
   TranslatedFrame::iterator value_iterator = translated_frame->begin();
   int input_index = 0;
 
   Builtins* builtins = isolate_->builtins();
   Code* construct_stub = builtins->builtin(Builtins::kJSConstructStubGeneric);
-  JSFunction* function = translated_frame->raw_function();
   unsigned height = translated_frame->height();
   unsigned height_in_bytes = height * kPointerSize;
+  JSFunction* function = JSFunction::cast(value_iterator->GetRawValue());
+  value_iterator++;
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating construct stub => height=%d\n", height_in_bytes);
   }
 
   unsigned fixed_frame_size = ConstructFrameConstants::kFrameSize;
   unsigned output_frame_size = height_in_bytes + fixed_frame_size;
 
   // Allocate and store the output frame description.
   FrameDescription* output_frame =
@@ skipping 145 matching lines @@
 
 
 void Deoptimizer::DoComputeAccessorStubFrame(TranslationIterator* iterator,
                                              int frame_index,
                                              bool is_setter_stub_frame) {
   TranslatedFrame* translated_frame =
       &(translated_state_.frames()[frame_index]);
   TranslatedFrame::iterator value_iterator = translated_frame->begin();
   int input_index = 0;
 
-  JSFunction* accessor = translated_frame->raw_function();
+  JSFunction* accessor = JSFunction::cast(value_iterator->GetRawValue());
+  value_iterator++;
   // The receiver (and the implicit return value, if any) are expected in
   // registers by the LoadIC/StoreIC, so they don't belong to the output stack
   // frame. This means that we have to use a height of 0.
   unsigned height = 0;
   unsigned height_in_bytes = height * kPointerSize;
   const char* kind = is_setter_stub_frame ? "setter" : "getter";
   if (trace_scope_ != NULL) {
     PrintF(trace_scope_->file(),
            "  translating %s stub => height=%u\n", kind, height_in_bytes);
   }
@@ skipping 420 matching lines @@
 
 void Deoptimizer::MaterializeHeapNumbersForDebuggerInspectableFrame(
     int frame_index, int parameter_count, int expression_count,
     DeoptimizedFrameInfo* info) {
   CHECK_EQ(DEBUGGER, bailout_type_);
 
   translated_state_.Prepare(false, nullptr);
 
   TranslatedFrame* frame = &(translated_state_.frames()[frame_index]);
   CHECK(frame->kind() == TranslatedFrame::kFunction);
-  int frame_arg_count =
-      frame->function()->shared()->internal_formal_parameter_count();
+  int frame_arg_count = frame->shared_info()->internal_formal_parameter_count();
 
   // The height is #expressions + 1 for context.
   CHECK_EQ(expression_count + 1, frame->height());
   TranslatedFrame* argument_frame = frame;
   if (frame_index > 0) {
     TranslatedFrame* previous_frame =
         &(translated_state_.frames()[frame_index - 1]);
     if (previous_frame->kind() == TranslatedFrame::kArgumentsAdaptor) {
       argument_frame = previous_frame;
       CHECK_EQ(parameter_count, argument_frame->height() - 1);
     } else {
       CHECK_EQ(frame_arg_count, parameter_count);
     }
   } else {
     CHECK_EQ(frame_arg_count, parameter_count);
   }
 
   TranslatedFrame::iterator arg_iter = argument_frame->begin();
+  arg_iter++;  // Skip the function.
   arg_iter++;  // Skip the receiver.
   for (int i = 0; i < parameter_count; i++, arg_iter++) {
     if (!arg_iter->IsMaterializedObject()) {
       info->SetParameter(i, *(arg_iter->GetValue()));
     }
   }
 
   TranslatedFrame::iterator iter = frame->begin();
-  // Skip the arguments, receiver and context.
-  for (int i = 0; i < frame_arg_count + 2; i++, iter++) {
+  // Skip the function, receiver, context and arguments.
+  for (int i = 0; i < frame_arg_count + 3; i++, iter++) {
   }
 
   for (int i = 0; i < expression_count; i++, iter++) {
     if (!iter->IsMaterializedObject()) {
       info->SetExpression(i, *(iter->GetValue()));
     }
   }
 }
 
 
@@ skipping 374 matching lines @@
 void Translation::StoreArgumentsObject(bool args_known,
                                        int args_index,
                                        int args_length) {
   buffer_->Add(ARGUMENTS_OBJECT, zone());
   buffer_->Add(args_known, zone());
   buffer_->Add(args_index, zone());
   buffer_->Add(args_length, zone());
 }
 
 
+void Translation::StoreJSFrameFunction() {
+  buffer_->Add(JS_FRAME_FUNCTION, zone());
+}
+
+
 int Translation::NumberOfOperandsFor(Opcode opcode) {
   switch (opcode) {
+    case JS_FRAME_FUNCTION:
+      return 0;
     case GETTER_STUB_FRAME:
     case SETTER_STUB_FRAME:
     case DUPLICATED_OBJECT:
     case ARGUMENTS_OBJECT:
     case CAPTURED_OBJECT:
     case REGISTER:
     case INT32_REGISTER:
     case UINT32_REGISTER:
     case BOOL_REGISTER:
     case DOUBLE_REGISTER:
@@ skipping 483 matching lines @@
 
 void TranslatedValue::Handlify() {
   if (kind() == kTagged) {
     value_ = Handle<Object>(raw_literal(), isolate());
     raw_literal_ = nullptr;
   }
 }
 
 
 TranslatedFrame TranslatedFrame::JSFrame(BailoutId node_id,
-                                         JSFunction* function, int height) {
-  TranslatedFrame frame(kFunction, function->GetIsolate(), function, height);
+                                         SharedFunctionInfo* shared_info,
+                                         int height) {
+  TranslatedFrame frame(kFunction, shared_info->GetIsolate(), shared_info,
+                        height);
   frame.node_id_ = node_id;
   return frame;
 }
 
 
-TranslatedFrame TranslatedFrame::AccessorFrame(Kind kind,
-                                               JSFunction* function) {
+TranslatedFrame TranslatedFrame::AccessorFrame(
+    Kind kind, SharedFunctionInfo* shared_info) {
   DCHECK(kind == kSetter || kind == kGetter);
-  return TranslatedFrame(kind, function->GetIsolate(), function);
+  return TranslatedFrame(kind, shared_info->GetIsolate(), shared_info);
 }
 
 
-TranslatedFrame TranslatedFrame::ArgumentsAdaptorFrame(JSFunction* function,
-                                                       int height) {
-  return TranslatedFrame(kArgumentsAdaptor, function->GetIsolate(), function,
+TranslatedFrame TranslatedFrame::ArgumentsAdaptorFrame(
+    SharedFunctionInfo* shared_info, int height) {
+  return TranslatedFrame(kArgumentsAdaptor, shared_info->GetIsolate(),
+                         shared_info, height);
+}
+
+
+TranslatedFrame TranslatedFrame::ConstructStubFrame(
+    SharedFunctionInfo* shared_info, int height) {
+  return TranslatedFrame(kConstructStub, shared_info->GetIsolate(), shared_info,
                          height);
 }
 
-
-TranslatedFrame TranslatedFrame::ConstructStubFrame(JSFunction* function,
-                                                    int height) {
-  return TranslatedFrame(kConstructStub, function->GetIsolate(), function,
-                         height);
-}
-
 
 int TranslatedFrame::GetValueCount() {
   switch (kind()) {
     case kFunction: {
       int parameter_count =
-          (raw_function_ == nullptr
-               ? function_->shared()->internal_formal_parameter_count()
-               : raw_function_->shared()->internal_formal_parameter_count()) +
-          1;
-      return height_ + parameter_count;
+          raw_shared_info_->internal_formal_parameter_count() + 1;
+      return height_ + parameter_count + 1;
     }
 
     case kGetter:
-      return 1;  // Receiver.
+      return 2;  // Function and receiver.
 
     case kSetter:
-      return 2;  // Receiver and the value to set.
+      return 3;  // Function, receiver and the value to set.
 
     case kArgumentsAdaptor:
     case kConstructStub:
+      return 1 + height_;
+
     case kCompiledStub:
       return height_;
 
     case kInvalid:
       UNREACHABLE();
       break;
   }
   UNREACHABLE();
   return -1;
 }
 
 
-void TranslatedFrame::Handlify(Isolate* isolate) {
-  if (raw_function_ != nullptr) {
-    function_ = Handle<JSFunction>(raw_function_, isolate);
-    raw_function_ = nullptr;
+void TranslatedFrame::Handlify() {
+  if (raw_shared_info_ != nullptr) {
+    shared_info_ = Handle<SharedFunctionInfo>(raw_shared_info_);
+    raw_shared_info_ = nullptr;
   }
   for (auto& value : values_) {
     value.Handlify();
   }
 }
 
 
 TranslatedFrame TranslatedState::CreateNextTranslatedFrame(
     TranslationIterator* iterator, FixedArray* literal_array, Address fp,
     JSFunction* frame_function, FILE* trace_file) {
   Translation::Opcode opcode =
       static_cast<Translation::Opcode>(iterator->Next());
   switch (opcode) {
     case Translation::JS_FRAME: {
       BailoutId node_id = BailoutId(iterator->Next());
-      int closure_id = iterator->Next();
-      JSFunction* function =
-          (closure_id == Translation::kSelfLiteralId)
-              ? frame_function
-              : JSFunction::cast(literal_array->get(closure_id));
+      SharedFunctionInfo* shared_info =
+          SharedFunctionInfo::cast(literal_array->get(iterator->Next()));
       int height = iterator->Next();
       if (trace_file != nullptr) {
-        PrintF(trace_file, "  reading input frame ");
-        function->PrintName(trace_file);
-        int arg_count =
-            function->shared()->internal_formal_parameter_count() + 1;
+        SmartArrayPointer<char> name = shared_info->DebugName()->ToCString();
+        PrintF(trace_file, "  reading input frame %s", name.get());
+        int arg_count = shared_info->internal_formal_parameter_count() + 1;
         PrintF(trace_file, " => node=%d, args=%d, height=%d; inputs:\n",
                arg_count, node_id.ToInt(), height);
       }
-      return TranslatedFrame::JSFrame(node_id, function, height);
+      return TranslatedFrame::JSFrame(node_id, shared_info, height);
     }
 
     case Translation::ARGUMENTS_ADAPTOR_FRAME: {
-      JSFunction* function =
-          JSFunction::cast(literal_array->get(iterator->Next()));
+      SharedFunctionInfo* shared_info =
+          SharedFunctionInfo::cast(literal_array->get(iterator->Next()));
       int height = iterator->Next();
       if (trace_file != nullptr) {
-        PrintF(trace_file, "  reading arguments adaptor frame");
-        function->PrintName(trace_file);
+        SmartArrayPointer<char> name = shared_info->DebugName()->ToCString();
+        PrintF(trace_file, "  reading arguments adaptor frame %s", name.get());
         PrintF(trace_file, " => height=%d; inputs:\n", height);
       }
-      return TranslatedFrame::ArgumentsAdaptorFrame(function, height);
+      return TranslatedFrame::ArgumentsAdaptorFrame(shared_info, height);
     }
 
     case Translation::CONSTRUCT_STUB_FRAME: {
-      JSFunction* function =
-          JSFunction::cast(literal_array->get(iterator->Next()));
+      SharedFunctionInfo* shared_info =
+          SharedFunctionInfo::cast(literal_array->get(iterator->Next()));
       int height = iterator->Next();
       if (trace_file != nullptr) {
-        PrintF(trace_file, "  reading construct stub frame ");
-        function->PrintName(trace_file);
+        SmartArrayPointer<char> name = shared_info->DebugName()->ToCString();
+        PrintF(trace_file, "  reading construct stub frame %s", name.get());
         PrintF(trace_file, " => height=%d; inputs:\n", height);
       }
-      return TranslatedFrame::ConstructStubFrame(function, height);
+      return TranslatedFrame::ConstructStubFrame(shared_info, height);
     }
 
     case Translation::GETTER_STUB_FRAME: {
-      JSFunction* function =
-          JSFunction::cast(literal_array->get(iterator->Next()));
+      SharedFunctionInfo* shared_info =
+          SharedFunctionInfo::cast(literal_array->get(iterator->Next()));
       if (trace_file != nullptr) {
-        PrintF(trace_file, "  reading getter frame ");
-        function->PrintName(trace_file);
-        PrintF(trace_file, "; inputs:\n");
+        SmartArrayPointer<char> name = shared_info->DebugName()->ToCString();
+        PrintF(trace_file, "  reading getter frame %s; inputs:\n", name.get());
       }
-      return TranslatedFrame::AccessorFrame(TranslatedFrame::kGetter, function);
+      return TranslatedFrame::AccessorFrame(TranslatedFrame::kGetter,
+                                            shared_info);
     }
 
     case Translation::SETTER_STUB_FRAME: {
-      JSFunction* function =
-          JSFunction::cast(literal_array->get(iterator->Next()));
+      SharedFunctionInfo* shared_info =
+          SharedFunctionInfo::cast(literal_array->get(iterator->Next()));
       if (trace_file != nullptr) {
-        PrintF(trace_file, "  reading setter frame ");
-        function->PrintName(trace_file);
-        PrintF(trace_file, "; inputs:\n");
+        SmartArrayPointer<char> name = shared_info->DebugName()->ToCString();
+        PrintF(trace_file, "  reading setter frame %s; inputs:\n", name.get());
       }
-      return TranslatedFrame::AccessorFrame(TranslatedFrame::kSetter, function);
+      return TranslatedFrame::AccessorFrame(TranslatedFrame::kSetter,
+                                            shared_info);
     }
 
     case Translation::COMPILED_STUB_FRAME: {
       int height = iterator->Next();
       if (trace_file != nullptr) {
         PrintF(trace_file,
                "  reading compiler stub frame => height=%d; inputs:\n", height);
       }
       return TranslatedFrame::CompiledStubFrame(height,
                                                 literal_array->GetIsolate());
     }
 
     case Translation::BEGIN:
     case Translation::DUPLICATED_OBJECT:
     case Translation::ARGUMENTS_OBJECT:
     case Translation::CAPTURED_OBJECT:
     case Translation::REGISTER:
     case Translation::INT32_REGISTER:
     case Translation::UINT32_REGISTER:
     case Translation::BOOL_REGISTER:
     case Translation::DOUBLE_REGISTER:
     case Translation::STACK_SLOT:
     case Translation::INT32_STACK_SLOT:
     case Translation::UINT32_STACK_SLOT:
     case Translation::BOOL_STACK_SLOT:
     case Translation::DOUBLE_STACK_SLOT:
     case Translation::LITERAL:
+    case Translation::JS_FRAME_FUNCTION:
       break;
   }
   FATAL("We should never get here - unexpected deopt info.");
   return TranslatedFrame::InvalidFrame();
 }
 
 
 // static
 void TranslatedFrame::AdvanceIterator(
     std::deque<TranslatedValue>::iterator* iter) {
@@ skipping 176 matching lines @@
       int literal_index = iterator->Next();
       Object* value = literal_array->get(literal_index);
       if (trace_file != nullptr) {
         PrintF(trace_file, "0x%08" V8PRIxPTR " ; (literal %d) ",
                reinterpret_cast<intptr_t>(value), literal_index);
         reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
       }
 
       return TranslatedValue::NewTagged(this, value);
     }
+
+    case Translation::JS_FRAME_FUNCTION: {
+      int slot_offset = JavaScriptFrameConstants::kFunctionOffset;
+      intptr_t value = *(reinterpret_cast<intptr_t*>(fp + slot_offset));
+      if (trace_file != nullptr) {
+        PrintF(trace_file, "0x%08" V8PRIxPTR " ; (frame function) ", value);
+        reinterpret_cast<Object*>(value)->ShortPrint(trace_file);
+      }
+      return TranslatedValue::NewTagged(this, reinterpret_cast<Object*>(value));
+    }
   }
 
   FATAL("We should never get here - unexpected deopt info.");
   return TranslatedValue(nullptr, TranslatedValue::kInvalid);
 }
 
 
 TranslatedState::TranslatedState(JavaScriptFrame* frame)
     : isolate_(nullptr),
       stack_frame_pointer_(nullptr),
@@ skipping 84 matching lines @@
   }
 
   CHECK(!iterator->HasNext() ||
         static_cast<Translation::Opcode>(iterator->Next()) ==
             Translation::BEGIN);
 }
 
 
 void TranslatedState::Prepare(bool has_adapted_arguments,
                               Address stack_frame_pointer) {
-  for (auto& frame : frames_) {
-    frame.Handlify(isolate_);
-  }
+  for (auto& frame : frames_) frame.Handlify();
 
   stack_frame_pointer_ = stack_frame_pointer;
   has_adapted_arguments_ = has_adapted_arguments;
 
   UpdateFromPreviouslyMaterializedObjects();
 }
 
 
 Handle<Object> TranslatedState::MaterializeAt(int frame_index,
                                               int* value_index) {
@@ skipping 19 matching lines @@
 
     case TranslatedValue::kArgumentsObject: {
       int length = slot->GetChildrenCount();
       Handle<JSObject> arguments;
       if (GetAdaptedArguments(&arguments, frame_index)) {
         // Store the materialized object and consume the nested values.
         for (int i = 0; i < length; ++i) {
           MaterializeAt(frame_index, value_index);
         }
       } else {
-        Handle<JSFunction> function = frame->function();
+        Handle<JSFunction> function =
+            Handle<JSFunction>::cast(frame->front().GetValue());
         arguments = isolate_->factory()->NewArgumentsObject(function, length);
         Handle<FixedArray> array = isolate_->factory()->NewFixedArray(length);
         DCHECK_EQ(array->length(), length);
         arguments->set_elements(*array);
         for (int i = 0; i < length; ++i) {
           Handle<Object> value = MaterializeAt(frame_index, value_index);
           array->set(i, *value);
         }
       }
       slot->value_ = arguments;
@@ skipping 110 matching lines @@
 
 bool TranslatedState::GetAdaptedArguments(Handle<JSObject>* result,
                                           int frame_index) {
   if (frame_index == 0) {
     // Top level frame -> we need to go to the parent frame on the stack.
     if (!has_adapted_arguments_) return false;
 
     // This is top level frame, so we need to go to the stack to get
     // this function's argument. (Note that this relies on not inlining
     // recursive functions!)
-    Handle<JSFunction> function = frames_[frame_index].function();
+    Handle<JSFunction> function =
+        Handle<JSFunction>::cast(frames_[frame_index].front().GetValue());
     *result = Handle<JSObject>::cast(Accessors::FunctionGetArguments(function));
     return true;
   } else {
     TranslatedFrame* previous_frame = &(frames_[frame_index]);
     if (previous_frame->kind() != TranslatedFrame::kArgumentsAdaptor) {
       return false;
     }
     // We get the adapted arguments from the parent translation.
-    int length = previous_frame->GetValueCount();
-    Handle<JSFunction> function = previous_frame->function();
+    int length = previous_frame->height();
+    Handle<JSFunction> function =
+        Handle<JSFunction>::cast(previous_frame->front().GetValue());
     Handle<JSObject> arguments =
         isolate_->factory()->NewArgumentsObject(function, length);
     Handle<FixedArray> array = isolate_->factory()->NewFixedArray(length);
     arguments->set_elements(*array);
     TranslatedFrame::iterator arg_iterator = previous_frame->begin();
+    arg_iterator++;  // Skip function.
     for (int i = 0; i < length; ++i) {
       Handle<Object> value = arg_iterator->GetValue();
       array->set(i, *value);
       arg_iterator++;
     }
     CHECK(arg_iterator == previous_frame->end());
     *result = arguments;
     return true;
   }
 }
 
 
 TranslatedFrame* TranslatedState::GetArgumentsInfoFromJSFrameIndex(
     int jsframe_index, int* args_count) {
   for (size_t i = 0; i < frames_.size(); i++) {
     if (frames_[i].kind() == TranslatedFrame::kFunction) {
       if (jsframe_index > 0) {
         jsframe_index--;
       } else {
         // We have the JS function frame, now check if it has arguments adaptor.
         if (i > 0 &&
             frames_[i - 1].kind() == TranslatedFrame::kArgumentsAdaptor) {
           *args_count = frames_[i - 1].height();
           return &(frames_[i - 1]);
         }
         *args_count =
-            frames_[i].function()->shared()->internal_formal_parameter_count() +
-            1;
+            frames_[i].shared_info()->internal_formal_parameter_count() + 1;
         return &(frames_[i]);
       }
     }
   }
   return nullptr;
 }
 
 
 void TranslatedState::StoreMaterializedValuesAndDeopt() {
   MaterializedObjectStore* materialized_store =
@@ skipping 31 matching lines @@
         previously_materialized_objects->set(i, *value);
         value_changed = true;
       } else {
         DCHECK(previously_materialized_objects->get(i) == *value);
       }
     }
   }
   if (new_store && value_changed) {
     materialized_store->Set(stack_frame_pointer_,
                             previously_materialized_objects);
-    DCHECK(frames_[0].kind() == TranslatedFrame::kFunction);
-    Deoptimizer::DeoptimizeFunction(*(frames_[0].function()));
+    DCHECK_EQ(TranslatedFrame::kFunction, frames_[0].kind());
+    Object* const function = frames_[0].front().GetRawValue();
+    Deoptimizer::DeoptimizeFunction(JSFunction::cast(function));
   }
 }
 
 
 void TranslatedState::UpdateFromPreviouslyMaterializedObjects() {
   MaterializedObjectStore* materialized_store =
       isolate_->materialized_object_store();
   Handle<FixedArray> previously_materialized_objects =
       materialized_store->Get(stack_frame_pointer_);
 
@@ skipping 15 matching lines @@
       DCHECK(value_info->IsMaterializedObject());
 
       value_info->value_ =
           Handle<Object>(previously_materialized_objects->get(i), isolate_);
     }
   }
 }
 
 }  // namespace internal
 }  // namespace v8