v8::internal::LiveEdit Class Reference

#include <liveedit.h>

Inheritance diagram for v8::internal::LiveEdit:

Collaboration diagram for v8::internal::LiveEdit:

Public Types
enum	FrameDropMode {   FRAMES_UNTOUCHED , FRAME_DROPPED_IN_IC_CALL , FRAME_DROPPED_IN_DEBUG_SLOT_CALL , FRAME_DROPPED_IN_DIRECT_CALL ,   FRAME_DROPPED_IN_RETURN_CALL , CURRENTLY_SET_MODE }
enum	FunctionPatchabilityStatus {   FUNCTION_AVAILABLE_FOR_PATCH = 1 , FUNCTION_BLOCKED_ON_ACTIVE_STACK = 2 , FUNCTION_BLOCKED_ON_OTHER_STACK = 3 , FUNCTION_BLOCKED_UNDER_NATIVE_CODE = 4 ,   FUNCTION_REPLACED_ON_ACTIVE_STACK = 5 , FUNCTION_BLOCKED_UNDER_GENERATOR = 6 , FUNCTION_BLOCKED_ACTIVE_GENERATOR = 7 }

Static Public Member Functions
static void	InitializeThreadLocal (Debug *debug)
static bool	SetAfterBreakTarget (Debug *debug)
static MUST_USE_RESULT MaybeHandle< JSArray >	GatherCompileInfo (Handle< Script > script, Handle< String > source)
static void	WrapSharedFunctionInfos (Handle< JSArray > array)
static void	ReplaceFunctionCode (Handle< JSArray > new_compile_info_array, Handle< JSArray > shared_info_array)
static void	FunctionSourceUpdated (Handle< JSArray > shared_info_array)
static void	SetFunctionScript (Handle< JSValue > function_wrapper, Handle< Object > script_handle)
static void	PatchFunctionPositions (Handle< JSArray > shared_info_array, Handle< JSArray > position_change_array)
static Handle< Object >	ChangeScriptSource (Handle< Script > original_script, Handle< String > new_source, Handle< Object > old_script_name)
static void	ReplaceRefToNestedFunction (Handle< JSValue > parent_function_shared, Handle< JSValue > orig_function_shared, Handle< JSValue > subst_function_shared)
static bool	FindActiveGenerators (Handle< FixedArray > shared_info_array, Handle< FixedArray > result, int len)
static Handle< JSArray >	CheckAndDropActivations (Handle< JSArray > shared_info_array, bool do_drop)
static const char *	RestartFrame (JavaScriptFrame *frame)
static Handle< JSArray >	CompareStrings (Handle< String > s1, Handle< String > s2)

Static Public Attributes
static const bool	kFrameDropperSupported
static const int	kFrameDropperFrameSize = 4
	Defines layout of a stack frame that supports padding. More...
static const int	kFramePaddingInitialSize = 1
static const int	kFramePaddingValue = kFramePaddingInitialSize + 1

Detailed Description

Definition at line 59 of file liveedit.h.

Member Enumeration Documentation

FrameDropMode

enum v8::internal::LiveEdit::FrameDropMode

Enumerator
FRAMES_UNTOUCHED
FRAME_DROPPED_IN_IC_CALL
FRAME_DROPPED_IN_DEBUG_SLOT_CALL
FRAME_DROPPED_IN_DIRECT_CALL
FRAME_DROPPED_IN_RETURN_CALL
CURRENTLY_SET_MODE

Definition at line 62 of file liveedit.h.

                     {
    // No frame has been dropped.
    FRAMES_UNTOUCHED,
    // The top JS frame had been calling IC stub. IC stub mustn't be called now.
    FRAME_DROPPED_IN_IC_CALL,
    // The top JS frame had been calling debug break slot stub. Patch the
    // address this stub jumps to in the end.
    FRAME_DROPPED_IN_DEBUG_SLOT_CALL,
    // The top JS frame had been calling some C++ function. The return address
    // gets patched automatically.
    FRAME_DROPPED_IN_DIRECT_CALL,
    FRAME_DROPPED_IN_RETURN_CALL,
    CURRENTLY_SET_MODE
  };

FunctionPatchabilityStatus

enum v8::internal::LiveEdit::FunctionPatchabilityStatus

Enumerator
FUNCTION_AVAILABLE_FOR_PATCH
FUNCTION_BLOCKED_ON_ACTIVE_STACK
FUNCTION_BLOCKED_ON_OTHER_STACK
FUNCTION_BLOCKED_UNDER_NATIVE_CODE
FUNCTION_REPLACED_ON_ACTIVE_STACK
FUNCTION_BLOCKED_UNDER_GENERATOR
FUNCTION_BLOCKED_ACTIVE_GENERATOR

Definition at line 130 of file liveedit.h.

                                  {
    FUNCTION_AVAILABLE_FOR_PATCH = 1,
    FUNCTION_BLOCKED_ON_ACTIVE_STACK = 2,
    FUNCTION_BLOCKED_ON_OTHER_STACK = 3,
    FUNCTION_BLOCKED_UNDER_NATIVE_CODE = 4,
    FUNCTION_REPLACED_ON_ACTIVE_STACK = 5,
    FUNCTION_BLOCKED_UNDER_GENERATOR = 6,
    FUNCTION_BLOCKED_ACTIVE_GENERATOR = 7
  };

Member Function Documentation

ChangeScriptSource()

Handle< Object > v8::internal::LiveEdit::ChangeScriptSource ( Handle< Script >  original_script, Handle< String >  new_source, Handle< Object >  old_script_name  )

static

Definition at line 1471 of file liveedit.cc.

                                                                            {
  Isolate* isolate = original_script->GetIsolate();
  Handle<Object> old_script_object;
  if (old_script_name->IsString()) {
    Handle<Script> old_script = CreateScriptCopy(original_script);
    old_script->set_name(String::cast(*old_script_name));
    old_script_object = old_script;
    isolate->debug()->OnAfterCompile(old_script);
  } else {
    old_script_object = isolate->factory()->null_value();
  }
 
  original_script->set_source(*new_source);
 
  // Drop line ends so that they will be recalculated.
  original_script->set_line_ends(isolate->heap()->undefined_value());
 
  return old_script_object;
}

References v8::internal::CreateScriptCopy(), v8::internal::Isolate::debug(), v8::internal::Isolate::factory(), v8::internal::Isolate::heap(), and v8::internal::Debug::OnAfterCompile().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

CheckAndDropActivations()

Handle< JSArray > v8::internal::LiveEdit::CheckAndDropActivations ( Handle< JSArray >  shared_info_array, bool  do_drop  )

static

Definition at line 1955 of file liveedit.cc.

                                                     {
  Isolate* isolate = shared_info_array->GetIsolate();
  int len = GetArrayLength(shared_info_array);
 
  DCHECK(shared_info_array->HasFastElements());
  Handle<FixedArray> shared_info_array_elements(
      FixedArray::cast(shared_info_array->elements()));
 
  Handle<JSArray> result = isolate->factory()->NewJSArray(len);
  Handle<FixedArray> result_elements =
      JSObject::EnsureWritableFastElements(result);
 
  // Fill the default values.
  for (int i = 0; i < len; i++) {
    FunctionPatchabilityStatus status = FUNCTION_AVAILABLE_FOR_PATCH;
    result_elements->set(i, Smi::FromInt(status));
  }
 
  // Scan the heap for active generators -- those that are either currently
  // running (as we wouldn't want to restart them, because we don't know where
  // to restart them from) or suspended.  Fail if any one corresponds to the set
  // of functions being edited.
  if (FindActiveGenerators(shared_info_array_elements, result_elements, len)) {
    return result;
  }
 
  // Check inactive threads. Fail if some functions are blocked there.
  InactiveThreadActivationsChecker inactive_threads_checker(shared_info_array,
                                                            result);
  isolate->thread_manager()->IterateArchivedThreads(
      &inactive_threads_checker);
  if (inactive_threads_checker.HasBlockedFunctions()) {
    return result;
  }
 
  // Try to drop activations from the current stack.
  const char* error_message =
      DropActivationsInActiveThread(shared_info_array, result, do_drop);
  if (error_message != NULL) {
    // Add error message as an array extra element.
    Handle<String> str =
        isolate->factory()->NewStringFromAsciiChecked(error_message);
    SetElementSloppy(result, len, str);
  }
  return result;
}

References DCHECK, v8::internal::DropActivationsInActiveThread(), v8::internal::JSObject::EnsureWritableFastElements(), v8::internal::Isolate::factory(), FindActiveGenerators(), v8::internal::Smi::FromInt(), FUNCTION_AVAILABLE_FOR_PATCH, v8::internal::GetArrayLength(), v8::internal::InactiveThreadActivationsChecker::HasBlockedFunctions(), v8::internal::ThreadManager::IterateArchivedThreads(), NULL, v8::internal::SetElementSloppy(), and v8::internal::Isolate::thread_manager().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

CompareStrings()

Handle< JSArray > v8::internal::LiveEdit::CompareStrings ( Handle< String >  s1, Handle< String >  s2  )

static

Definition at line 556 of file liveedit.cc.

                                                            {
  s1 = String::Flatten(s1);
  s2 = String::Flatten(s2);
 
  LineEndsWrapper line_ends1(s1);
  LineEndsWrapper line_ends2(s2);
 
  LineArrayCompareInput input(s1, s2, line_ends1, line_ends2);
  TokenizingLineArrayCompareOutput output(line_ends1, line_ends2, s1, s2);
 
  NarrowDownInput(&input, &output);
 
  Comparator::CalculateDifference(&input, &output);
 
  return output.GetResult();
}

References v8::internal::Comparator::CalculateDifference(), v8::internal::String::Flatten(), v8::internal::TokenizingLineArrayCompareOutput::GetResult(), v8::internal::NarrowDownInput(), v8::internal::s1, and v8::internal::s2.

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

FindActiveGenerators()

bool v8::internal::LiveEdit::FindActiveGenerators ( Handle< FixedArray >  shared_info_array, Handle< FixedArray >  result, int  len  )

static

Definition at line 1892 of file liveedit.cc.

                                             {
  Isolate* isolate = shared_info_array->GetIsolate();
  bool found_suspended_activations = false;
 
  DCHECK_LE(len, result->length());
 
  FunctionPatchabilityStatus active = FUNCTION_BLOCKED_ACTIVE_GENERATOR;
 
  Heap* heap = isolate->heap();
  HeapIterator iterator(heap);
  HeapObject* obj = NULL;
  while ((obj = iterator.next()) != NULL) {
    if (!obj->IsJSGeneratorObject()) continue;
 
    JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
    if (gen->is_closed()) continue;
 
    HandleScope scope(isolate);
 
    for (int i = 0; i < len; i++) {
      Handle<JSValue> jsvalue =
          Handle<JSValue>::cast(FixedArray::get(shared_info_array, i));
      Handle<SharedFunctionInfo> shared =
          UnwrapSharedFunctionInfoFromJSValue(jsvalue);
 
      if (gen->function()->shared() == *shared) {
        result->set(i, Smi::FromInt(active));
        found_suspended_activations = true;
      }
    }
  }
 
  return found_suspended_activations;
}

References v8::internal::Handle< T >::cast(), DCHECK_LE, v8::internal::Smi::FromInt(), FUNCTION_BLOCKED_ACTIVE_GENERATOR, v8::internal::FixedArray::get(), v8::internal::Isolate::heap(), v8::internal::JSGeneratorObject::is_closed(), NULL, and v8::internal::UnwrapSharedFunctionInfoFromJSValue().

Referenced by CheckAndDropActivations().

Here is the call graph for this function:

Here is the caller graph for this function:

FunctionSourceUpdated()

void v8::internal::LiveEdit::FunctionSourceUpdated ( Handle< JSArray >  shared_info_array )

static

Definition at line 1233 of file liveedit.cc.

                                                                      {
  SharedInfoWrapper shared_info_wrapper(shared_info_array);
  Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
 
  DeoptimizeDependentFunctions(*shared_info);
  shared_info_array->GetIsolate()->compilation_cache()->Remove(shared_info);
}

References v8::internal::DeoptimizeDependentFunctions(), and v8::internal::SharedInfoWrapper::GetInfo().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

GatherCompileInfo()

MaybeHandle< JSArray > v8::internal::LiveEdit::GatherCompileInfo ( Handle< Script >  script, Handle< String >  source  )

static

Definition at line 843 of file liveedit.cc.

                                                                        {
  Isolate* isolate = script->GetIsolate();
 
  FunctionInfoListener listener(isolate);
  Handle<Object> original_source =
      Handle<Object>(script->source(), isolate);
  script->set_source(*source);
  isolate->set_active_function_info_listener(&listener);
 
  {
    // Creating verbose TryCatch from public API is currently the only way to
    // force code save location. We do not use this the object directly.
    v8::TryCatch try_catch;
    try_catch.SetVerbose(true);
 
    // A logical 'try' section.
    Compiler::CompileForLiveEdit(script);
  }
 
  // A logical 'catch' section.
  Handle<JSObject> rethrow_exception;
  if (isolate->has_pending_exception()) {
    Handle<Object> exception(isolate->pending_exception(), isolate);
    MessageLocation message_location = isolate->GetMessageLocation();
 
    isolate->clear_pending_message();
    isolate->clear_pending_exception();
 
    // If possible, copy positions from message object to exception object.
    if (exception->IsJSObject() && !message_location.script().is_null()) {
      rethrow_exception = Handle<JSObject>::cast(exception);
 
      Factory* factory = isolate->factory();
      Handle<String> start_pos_key = factory->InternalizeOneByteString(
          STATIC_CHAR_VECTOR("startPosition"));
      Handle<String> end_pos_key =
          factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("endPosition"));
      Handle<String> script_obj_key =
          factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptObject"));
      Handle<Smi> start_pos(
          Smi::FromInt(message_location.start_pos()), isolate);
      Handle<Smi> end_pos(Smi::FromInt(message_location.end_pos()), isolate);
      Handle<JSObject> script_obj =
          Script::GetWrapper(message_location.script());
      Object::SetProperty(rethrow_exception, start_pos_key, start_pos, SLOPPY)
          .Assert();
      Object::SetProperty(rethrow_exception, end_pos_key, end_pos, SLOPPY)
          .Assert();
      Object::SetProperty(rethrow_exception, script_obj_key, script_obj, SLOPPY)
          .Assert();
    }
  }
 
  // A logical 'finally' section.
  isolate->set_active_function_info_listener(NULL);
  script->set_source(*original_source);
 
  if (rethrow_exception.is_null()) {
    return listener.GetResult();
  } else {
    return isolate->Throw<JSArray>(rethrow_exception);
  }
}

References v8::internal::Handle< T >::cast(), v8::internal::Isolate::clear_pending_exception(), v8::internal::Isolate::clear_pending_message(), v8::internal::Compiler::CompileForLiveEdit(), v8::internal::MessageLocation::end_pos(), v8::internal::Isolate::factory(), v8::internal::Smi::FromInt(), v8::internal::Isolate::GetMessageLocation(), v8::internal::FunctionInfoListener::GetResult(), v8::internal::Script::GetWrapper(), v8::internal::Isolate::has_pending_exception(), v8::internal::Handle< T >::is_null(), NULL, v8::internal::Isolate::pending_exception(), v8::internal::MessageLocation::script(), v8::internal::Object::SetProperty(), v8::TryCatch::SetVerbose(), v8::internal::SLOPPY, v8::internal::MessageLocation::start_pos(), STATIC_CHAR_VECTOR, and v8::internal::Isolate::Throw().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

InitializeThreadLocal()

void v8::internal::LiveEdit::InitializeThreadLocal ( Debug *  debug )

static

Definition at line 808 of file liveedit.cc.

                                                 {
  debug->thread_local_.frame_drop_mode_ = LiveEdit::FRAMES_UNTOUCHED;
}

References v8::internal::Debug::ThreadLocal::frame_drop_mode_, FRAMES_UNTOUCHED, and v8::internal::Debug::thread_local_.

Referenced by v8::internal::Debug::Break().

Here is the caller graph for this function:

PatchFunctionPositions()

void v8::internal::LiveEdit::PatchFunctionPositions ( Handle< JSArray >  shared_info_array, Handle< JSArray >  position_change_array  )

static

Definition at line 1415 of file liveedit.cc.

                                                                             {
  SharedInfoWrapper shared_info_wrapper(shared_info_array);
  Handle<SharedFunctionInfo> info = shared_info_wrapper.GetInfo();
 
  int old_function_start = info->start_position();
  int new_function_start = TranslatePosition(old_function_start,
                                             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())) {
    // 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);
    }
  }
}

References v8::internal::SharedInfoWrapper::GetInfo(), v8::internal::IsJSFunctionCode(), v8::internal::PatchPositionsInCode(), v8::internal::ReplaceCodeObject(), and v8::internal::TranslatePosition().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

ReplaceFunctionCode()

void v8::internal::LiveEdit::ReplaceFunctionCode ( Handle< JSArray >  new_compile_info_array, Handle< JSArray >  shared_info_array  )

static

Definition at line 1187 of file liveedit.cc.

                                       {
  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())) {
    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
    Handle<TypeFeedbackVector> feedback_vector =
        compile_info_wrapper.GetFeedbackVector();
    shared_info->set_feedback_vector(*feedback_vector);
  }
 
  if (shared_info->debug_info()->IsDebugInfo()) {
    Handle<DebugInfo> debug_info(DebugInfo::cast(shared_info->debug_info()));
    Handle<Code> new_original_code =
        isolate->factory()->CopyCode(compile_info_wrapper.GetFunctionCode());
    debug_info->set_original_code(*new_original_code);
  }
 
  int start_position = compile_info_wrapper.GetStartPosition();
  int end_position = compile_info_wrapper.GetEndPosition();
  shared_info->set_start_position(start_position);
  shared_info->set_end_position(end_position);
 
  LiteralFixer::PatchLiterals(&compile_info_wrapper, shared_info, isolate);
 
  shared_info->set_construct_stub(
      isolate->builtins()->builtin(Builtins::kJSConstructStubGeneric));
 
  DeoptimizeDependentFunctions(*shared_info);
  isolate->compilation_cache()->Remove(shared_info);
}

References v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), v8::internal::Isolate::compilation_cache(), v8::internal::DeoptimizeDependentFunctions(), v8::internal::Isolate::factory(), v8::internal::feedback_vector, v8::internal::FunctionInfoWrapper::GetCodeScopeInfo(), v8::internal::FunctionInfoWrapper::GetEndPosition(), v8::internal::FunctionInfoWrapper::GetFeedbackVector(), v8::internal::FunctionInfoWrapper::GetFunctionCode(), v8::internal::SharedInfoWrapper::GetInfo(), v8::internal::FunctionInfoWrapper::GetStartPosition(), v8::internal::IsJSFunctionCode(), v8::internal::LiteralFixer::PatchLiterals(), v8::internal::CompilationCache::Remove(), and v8::internal::ReplaceCodeObject().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

ReplaceRefToNestedFunction()

void v8::internal::LiveEdit::ReplaceRefToNestedFunction ( Handle< JSValue >  parent_function_shared, Handle< JSValue >  orig_function_shared, Handle< JSValue >  subst_function_shared  )

static

Definition at line 1495 of file liveedit.cc.

                                            {
 
  Handle<SharedFunctionInfo> parent_shared =
      UnwrapSharedFunctionInfoFromJSValue(parent_function_wrapper);
  Handle<SharedFunctionInfo> orig_shared =
      UnwrapSharedFunctionInfoFromJSValue(orig_function_wrapper);
  Handle<SharedFunctionInfo> subst_shared =
      UnwrapSharedFunctionInfoFromJSValue(subst_function_wrapper);
 
  for (RelocIterator it(parent_shared->code()); !it.done(); it.next()) {
    if (it.rinfo()->rmode() == RelocInfo::EMBEDDED_OBJECT) {
      if (it.rinfo()->target_object() == *orig_shared) {
        it.rinfo()->set_target_object(*subst_shared);
      }
    }
  }
}

References v8::internal::RelocIterator::done(), v8::internal::RelocInfo::EMBEDDED_OBJECT, and v8::internal::UnwrapSharedFunctionInfoFromJSValue().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

RestartFrame()

const char * v8::internal::LiveEdit::RestartFrame ( JavaScriptFrame *  frame )

static

Definition at line 2034 of file liveedit.cc.

                                                         {
  SingleFrameTarget target(frame);
 
  const char* result = DropActivationsInActiveThreadImpl(
      frame->isolate(), target, true);
  if (result != NULL) {
    return result;
  }
  if (target.saved_status() == LiveEdit::FUNCTION_BLOCKED_UNDER_NATIVE_CODE) {
    return "Function is blocked under native code";
  }
  if (target.saved_status() == LiveEdit::FUNCTION_BLOCKED_UNDER_GENERATOR) {
    return "Function is blocked under a generator activation";
  }
  return NULL;
}

References v8::internal::DropActivationsInActiveThreadImpl(), FUNCTION_BLOCKED_UNDER_GENERATOR, FUNCTION_BLOCKED_UNDER_NATIVE_CODE, NULL, and v8::internal::SingleFrameTarget::saved_status().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

SetAfterBreakTarget()

bool v8::internal::LiveEdit::SetAfterBreakTarget ( Debug *  debug )

static

Definition at line 813 of file liveedit.cc.

                                               {
  Code* code = NULL;
  Isolate* isolate = debug->isolate_;
  switch (debug->thread_local_.frame_drop_mode_) {
    case FRAMES_UNTOUCHED:
      return false;
    case FRAME_DROPPED_IN_IC_CALL:
      // We must have been calling IC stub. Do not go there anymore.
      code = isolate->builtins()->builtin(Builtins::kPlainReturn_LiveEdit);
      break;
    case FRAME_DROPPED_IN_DEBUG_SLOT_CALL:
      // Debug break slot stub does not return normally, instead it manually
      // cleans the stack and jumps. We should patch the jump address.
      code = isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit);
      break;
    case FRAME_DROPPED_IN_DIRECT_CALL:
      // Nothing to do, after_break_target is not used here.
      return true;
    case FRAME_DROPPED_IN_RETURN_CALL:
      code = isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit);
      break;
    case CURRENTLY_SET_MODE:
      UNREACHABLE();
      break;
  }
  debug->after_break_target_ = code->entry();
  return true;
}

References v8::internal::Debug::after_break_target_, v8::internal::Builtins::builtin(), v8::internal::Isolate::builtins(), CURRENTLY_SET_MODE, v8::internal::Code::entry(), v8::internal::Debug::ThreadLocal::frame_drop_mode_, FRAME_DROPPED_IN_DEBUG_SLOT_CALL, FRAME_DROPPED_IN_DIRECT_CALL, FRAME_DROPPED_IN_IC_CALL, FRAME_DROPPED_IN_RETURN_CALL, FRAMES_UNTOUCHED, v8::internal::Debug::isolate_, NULL, v8::internal::Debug::thread_local_, and UNREACHABLE.

Referenced by v8::internal::Debug::SetAfterBreakTarget().

Here is the call graph for this function:

Here is the caller graph for this function:

SetFunctionScript()

void v8::internal::LiveEdit::SetFunctionScript ( Handle< JSValue >  function_wrapper, Handle< Object >  script_handle  )

static

Definition at line 1242 of file liveedit.cc.

                                                               {
  Handle<SharedFunctionInfo> shared_info =
      UnwrapSharedFunctionInfoFromJSValue(function_wrapper);
  CHECK(script_handle->IsScript() || script_handle->IsUndefined());
  shared_info->set_script(*script_handle);
 
  function_wrapper->GetIsolate()->compilation_cache()->Remove(shared_info);
}

References CHECK, and v8::internal::UnwrapSharedFunctionInfoFromJSValue().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

WrapSharedFunctionInfos()

void v8::internal::LiveEdit::WrapSharedFunctionInfos ( Handle< JSArray >  array )

static

Definition at line 909 of file liveedit.cc.

                                                            {
  Isolate* isolate = array->GetIsolate();
  HandleScope scope(isolate);
  int len = GetArrayLength(array);
  for (int i = 0; i < len; i++) {
    Handle<SharedFunctionInfo> info(
        SharedFunctionInfo::cast(
            *Object::GetElement(isolate, array, i).ToHandleChecked()));
    SharedInfoWrapper info_wrapper = SharedInfoWrapper::Create(isolate);
    Handle<String> name_handle(String::cast(info->name()));
    info_wrapper.SetProperties(name_handle, info->start_position(),
                               info->end_position(), info);
    SetElementSloppy(array, i, info_wrapper.GetJSArray());
  }
}

References v8::internal::JSArrayBasedStruct< SharedInfoWrapper >::Create(), v8::internal::GetArrayLength(), v8::internal::Object::GetElement(), v8::internal::JSArrayBasedStruct< S >::GetJSArray(), v8::internal::SetElementSloppy(), and v8::internal::SharedInfoWrapper::SetProperties().

Referenced by v8::internal::RUNTIME_FUNCTION().

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

kFrameDropperFrameSize

const int v8::internal::LiveEdit::kFrameDropperFrameSize = 4

static

Defines layout of a stack frame that supports padding.

This is a regular internal frame that has a flexible stack structure. LiveEdit can shift its lower part up the stack, taking up the 'padding' space when additional stack memory is required. Such frame is expected immediately above the topmost JavaScript frame.

Stack Layout: — Top

LiveEdit routine frames

C frames of debug handler

...

An internal frame that has n padding words:

• any number of words as needed by code – upper part of frame
• padding size: a Smi storing n – current size of padding
• padding: n words filled with kPaddingValue in form of Smi
• 3 context/type words of a regular InternalFrame

- fp

Topmost JavaScript frame

... — Bottom

Definition at line 178 of file liveedit.h.

Referenced by v8::internal::DropFrames().

kFrameDropperSupported

const bool v8::internal::LiveEdit::kFrameDropperSupported

static

Definition at line 147 of file liveedit.h.

Referenced by v8::internal::DropFrames().

kFramePaddingInitialSize

const int v8::internal::LiveEdit::kFramePaddingInitialSize = 1

static

Definition at line 181 of file liveedit.h.

kFramePaddingValue

const int v8::internal::LiveEdit::kFramePaddingValue = kFramePaddingInitialSize + 1

static

Definition at line 184 of file liveedit.h.

Referenced by v8::internal::DropFrames().

---

The documentation for this class was generated from the following files:

• /mnt/V8SourceCode/src/liveedit.h
• /mnt/V8SourceCode/src/liveedit.cc