Debugger: prepare code for debugging on a per-function basis.

src/liveedit.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/v8.h"
 
 #include "src/liveedit.h"
 
 #include "src/code-stubs.h"
@@ skipping 1075 matching lines @@
       m_output->set(m_pos, fun);
       m_pos++;
     }
    private:
     Handle<FixedArray> m_output;
     int m_pos;
   };
 };
 
 
-namespace {
-
-// Check whether the code is natural function code (not a lazy-compile stub
-// code).
-bool IsJSFunctionCode(Code* code) { return code->kind() == Code::FUNCTION; }
-
-
-// Returns true if an instance of candidate were inlined into function's code.
-bool IsInlined(JSFunction* function, SharedFunctionInfo* candidate) {
-  DisallowHeapAllocation no_gc;
-
-  if (function->code()->kind() != Code::OPTIMIZED_FUNCTION) return false;
-
-  DeoptimizationInputData* const data =
-      DeoptimizationInputData::cast(function->code()->deoptimization_data());
-  if (data != function->GetIsolate()->heap()->empty_fixed_array()) {
-    FixedArray* const literals = data->LiteralArray();
-    int const inlined_count = data->InlinedFunctionCount()->value();
-    for (int i = 0; i < inlined_count; ++i) {
-      if (SharedFunctionInfo::cast(literals->get(i)) == candidate) {
-        return true;
-      }
-    }
-  }
-
-  return false;
-}
-
-}  // namespace
-
-
 // Marks code that shares the same shared function info or has inlined
 // code that shares the same function info.
 class DependentFunctionMarker: public OptimizedFunctionVisitor {
  public:
   SharedFunctionInfo* shared_info_;
   bool found_;
 
   explicit DependentFunctionMarker(SharedFunctionInfo* shared_info)
     : shared_info_(shared_info), found_(false) { }
 
   virtual void EnterContext(Context* context) { }  // Don't care.
   virtual void LeaveContext(Context* context)  { }  // Don't care.
   virtual void VisitFunction(JSFunction* function) {
     // It should be guaranteed by the iterator that everything is optimized.
     DCHECK(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
-    if (shared_info_ == function->shared() ||
-        IsInlined(function, shared_info_)) {
+    if (function->Inlines(shared_info_)) {
       // Mark the code for deoptimization.
       function->code()->set_marked_for_deoptimization(true);
       found_ = true;
     }
   }
 };
 
 
 static void DeoptimizeDependentFunctions(SharedFunctionInfo* function_info) {
   DisallowHeapAllocation no_allocation;
@@ skipping 11 matching lines @@
 void LiveEdit::ReplaceFunctionCode(
     Handle<JSArray> new_compile_info_array,
     Handle<JSArray> shared_info_array) {
   Isolate* isolate = new_compile_info_array->GetIsolate();
 
   FunctionInfoWrapper compile_info_wrapper(new_compile_info_array);
   SharedInfoWrapper shared_info_wrapper(shared_info_array);
 
   Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
-  if (IsJSFunctionCode(shared_info->code())) {
+  if (shared_info->code()->kind() == Code::FUNCTION) {
     Handle<Code> code = compile_info_wrapper.GetFunctionCode();
     ReplaceCodeObject(Handle<Code>(shared_info->code()), code);
     Handle<Object> code_scope_info = compile_info_wrapper.GetCodeScopeInfo();
     if (code_scope_info->IsFixedArray()) {
       shared_info->set_scope_info(ScopeInfo::cast(*code_scope_info));
     }
     shared_info->DisableOptimization(kLiveEdit);
     // Update the type feedback vector, if needed.
     MaybeHandle<TypeFeedbackVector> feedback_vector =
         compile_info_wrapper.GetFeedbackVector();
@@ skipping 210 matching lines @@
                                              position_change_array);
   int new_function_end = TranslatePosition(info->end_position(),
                                            position_change_array);
   int new_function_token_pos =
       TranslatePosition(info->function_token_position(), position_change_array);
 
   info->set_start_position(new_function_start);
   info->set_end_position(new_function_end);
   info->set_function_token_position(new_function_token_pos);
 
-  if (IsJSFunctionCode(info->code())) {
+  if (info->code()->kind() == Code::FUNCTION) {
     // Patch relocation info section of the code.
     Handle<Code> patched_code = PatchPositionsInCode(Handle<Code>(info->code()),
                                                      position_change_array);
     if (*patched_code != info->code()) {
       // Replace all references to the code across the heap. In particular,
       // some stubs may refer to this code and this code may be being executed
       // on stack (it is safe to substitute the code object on stack, because
       // we only change the structure of rinfo and leave instructions
       // untouched).
       ReplaceCodeObject(Handle<Code>(info->code()), patched_code);
@@ skipping 84 matching lines @@
   Isolate* isolate = shared_info_array->GetIsolate();
   int len = GetArrayLength(shared_info_array);
   for (int i = 0; i < len; i++) {
     HandleScope scope(isolate);
     Handle<Object> element =
         Object::GetElement(isolate, shared_info_array, i).ToHandleChecked();
     Handle<JSValue> jsvalue = Handle<JSValue>::cast(element);
     Handle<SharedFunctionInfo> shared =
         UnwrapSharedFunctionInfoFromJSValue(jsvalue);
 
-    if (function->shared() == *shared || IsInlined(*function, *shared)) {
+    if (function->Inlines(*shared)) {
       SetElementSloppy(result, i, Handle<Smi>(Smi::FromInt(status), isolate));
       return true;
     }
   }
   return false;
 }
 
 
 // Iterates over handler chain and removes all elements that are inside
 // frames being dropped.
@@ skipping 530 matching lines @@
   isolate_->active_function_info_listener()->FunctionCode(code);
 }
 
 
 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
   return isolate->active_function_info_listener() != NULL;
 }
 
 }  // namespace internal
 }  // namespace v8