1 // Copyright 2012 the V8 project authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
8 #include "src/liveedit.h"
10 #include "src/code-stubs.h"
11 #include "src/compilation-cache.h"
12 #include "src/compiler.h"
13 #include "src/debug.h"
14 #include "src/deoptimizer.h"
15 #include "src/global-handles.h"
16 #include "src/messages.h"
17 #include "src/parser.h"
18 #include "src/scopeinfo.h"
19 #include "src/scopes.h"
20 #include "src/v8memory.h"
25 void SetElementSloppy(Handle<JSObject> object,
27 Handle<Object> value) {
28 // Ignore return value from SetElement. It can only be a failure if there
29 // are element setters causing exceptions and the debugger context has none
31 JSObject::SetElement(object, index, value, NONE, SLOPPY).Assert();
35 // A simple implementation of dynamic programming algorithm. It solves
36 // the problem of finding the difference of 2 arrays. It uses a table of results
37 // of subproblems. Each cell contains a number together with 2-bit flag
38 // that helps building the chunk list.
41 explicit Differencer(Comparator::Input* input)
42 : input_(input), len1_(input->GetLength1()), len2_(input->GetLength2()) {
43 buffer_ = NewArray<int>(len1_ * len2_);
50 int array_size = len1_ * len2_;
51 for (int i = 0; i < array_size; i++) {
52 buffer_[i] = kEmptyCellValue;
56 // Makes sure that result for the full problem is calculated and stored
57 // in the table together with flags showing a path through subproblems.
59 CompareUpToTail(0, 0);
62 void SaveResult(Comparator::Output* chunk_writer) {
63 ResultWriter writer(chunk_writer);
70 Direction dir = get_direction(pos1, pos2);
90 writer.skip1(len1_ - pos1);
95 writer.skip2(len2_ - pos2);
104 Comparator::Input* input_;
115 MAX_DIRECTION_FLAG_VALUE = SKIP_ANY
118 // Computes result for a subtask and optionally caches it in the buffer table.
119 // All results values are shifted to make space for flags in the lower bits.
120 int CompareUpToTail(int pos1, int pos2) {
123 int cached_res = get_value4(pos1, pos2);
124 if (cached_res == kEmptyCellValue) {
127 if (input_->Equals(pos1, pos2)) {
128 res = CompareUpToTail(pos1 + 1, pos2 + 1);
131 int res1 = CompareUpToTail(pos1 + 1, pos2) +
132 (1 << kDirectionSizeBits);
133 int res2 = CompareUpToTail(pos1, pos2 + 1) +
134 (1 << kDirectionSizeBits);
138 } else if (res1 < res2) {
146 set_value4_and_dir(pos1, pos2, res, dir);
151 return (len1_ - pos1) << kDirectionSizeBits;
154 return (len2_ - pos2) << kDirectionSizeBits;
158 inline int& get_cell(int i1, int i2) {
159 return buffer_[i1 + i2 * len1_];
162 // Each cell keeps a value plus direction. Value is multiplied by 4.
163 void set_value4_and_dir(int i1, int i2, int value4, Direction dir) {
164 DCHECK((value4 & kDirectionMask) == 0);
165 get_cell(i1, i2) = value4 | dir;
168 int get_value4(int i1, int i2) {
169 return get_cell(i1, i2) & (kMaxUInt32 ^ kDirectionMask);
171 Direction get_direction(int i1, int i2) {
172 return static_cast<Direction>(get_cell(i1, i2) & kDirectionMask);
175 static const int kDirectionSizeBits = 2;
176 static const int kDirectionMask = (1 << kDirectionSizeBits) - 1;
177 static const int kEmptyCellValue = ~0u << kDirectionSizeBits;
179 // This method only holds static assert statement (unfortunately you cannot
180 // place one in class scope).
181 void StaticAssertHolder() {
182 STATIC_ASSERT(MAX_DIRECTION_FLAG_VALUE < (1 << kDirectionSizeBits));
187 explicit ResultWriter(Comparator::Output* chunk_writer)
188 : chunk_writer_(chunk_writer), pos1_(0), pos2_(0),
189 pos1_begin_(-1), pos2_begin_(-1), has_open_chunk_(false) {
196 void skip1(int len1) {
200 void skip2(int len2) {
209 Comparator::Output* chunk_writer_;
214 bool has_open_chunk_;
217 if (!has_open_chunk_) {
220 has_open_chunk_ = true;
225 if (has_open_chunk_) {
226 chunk_writer_->AddChunk(pos1_begin_, pos2_begin_,
227 pos1_ - pos1_begin_, pos2_ - pos2_begin_);
228 has_open_chunk_ = false;
235 void Comparator::CalculateDifference(Comparator::Input* input,
236 Comparator::Output* result_writer) {
237 Differencer differencer(input);
238 differencer.Initialize();
239 differencer.FillTable();
240 differencer.SaveResult(result_writer);
244 static bool CompareSubstrings(Handle<String> s1, int pos1,
245 Handle<String> s2, int pos2, int len) {
246 for (int i = 0; i < len; i++) {
247 if (s1->Get(i + pos1) != s2->Get(i + pos2)) {
255 // Additional to Input interface. Lets switch Input range to subrange.
256 // More elegant way would be to wrap one Input as another Input object
257 // and translate positions there, but that would cost us additional virtual
258 // call per comparison.
259 class SubrangableInput : public Comparator::Input {
261 virtual void SetSubrange1(int offset, int len) = 0;
262 virtual void SetSubrange2(int offset, int len) = 0;
266 class SubrangableOutput : public Comparator::Output {
268 virtual void SetSubrange1(int offset, int len) = 0;
269 virtual void SetSubrange2(int offset, int len) = 0;
273 static int min(int a, int b) {
274 return a < b ? a : b;
278 // Finds common prefix and suffix in input. This parts shouldn't take space in
279 // linear programming table. Enable subranging in input and output.
280 static void NarrowDownInput(SubrangableInput* input,
281 SubrangableOutput* output) {
282 const int len1 = input->GetLength1();
283 const int len2 = input->GetLength2();
285 int common_prefix_len;
286 int common_suffix_len;
289 common_prefix_len = 0;
290 int prefix_limit = min(len1, len2);
291 while (common_prefix_len < prefix_limit &&
292 input->Equals(common_prefix_len, common_prefix_len)) {
296 common_suffix_len = 0;
297 int suffix_limit = min(len1 - common_prefix_len, len2 - common_prefix_len);
299 while (common_suffix_len < suffix_limit &&
300 input->Equals(len1 - common_suffix_len - 1,
301 len2 - common_suffix_len - 1)) {
306 if (common_prefix_len > 0 || common_suffix_len > 0) {
307 int new_len1 = len1 - common_suffix_len - common_prefix_len;
308 int new_len2 = len2 - common_suffix_len - common_prefix_len;
310 input->SetSubrange1(common_prefix_len, new_len1);
311 input->SetSubrange2(common_prefix_len, new_len2);
313 output->SetSubrange1(common_prefix_len, new_len1);
314 output->SetSubrange2(common_prefix_len, new_len2);
319 // A helper class that writes chunk numbers into JSArray.
320 // Each chunk is stored as 3 array elements: (pos1_begin, pos1_end, pos2_end).
321 class CompareOutputArrayWriter {
323 explicit CompareOutputArrayWriter(Isolate* isolate)
324 : array_(isolate->factory()->NewJSArray(10)), current_size_(0) {}
326 Handle<JSArray> GetResult() {
330 void WriteChunk(int char_pos1, int char_pos2, int char_len1, int char_len2) {
331 Isolate* isolate = array_->GetIsolate();
332 SetElementSloppy(array_,
334 Handle<Object>(Smi::FromInt(char_pos1), isolate));
335 SetElementSloppy(array_,
337 Handle<Object>(Smi::FromInt(char_pos1 + char_len1),
339 SetElementSloppy(array_,
341 Handle<Object>(Smi::FromInt(char_pos2 + char_len2),
347 Handle<JSArray> array_;
352 // Represents 2 strings as 2 arrays of tokens.
353 // TODO(LiveEdit): Currently it's actually an array of charactres.
354 // Make array of tokens instead.
355 class TokensCompareInput : public Comparator::Input {
357 TokensCompareInput(Handle<String> s1, int offset1, int len1,
358 Handle<String> s2, int offset2, int len2)
359 : s1_(s1), offset1_(offset1), len1_(len1),
360 s2_(s2), offset2_(offset2), len2_(len2) {
362 virtual int GetLength1() {
365 virtual int GetLength2() {
368 bool Equals(int index1, int index2) {
369 return s1_->Get(offset1_ + index1) == s2_->Get(offset2_ + index2);
382 // Stores compare result in JSArray. Converts substring positions
383 // to absolute positions.
384 class TokensCompareOutput : public Comparator::Output {
386 TokensCompareOutput(CompareOutputArrayWriter* array_writer,
387 int offset1, int offset2)
388 : array_writer_(array_writer), offset1_(offset1), offset2_(offset2) {
391 void AddChunk(int pos1, int pos2, int len1, int len2) {
392 array_writer_->WriteChunk(pos1 + offset1_, pos2 + offset2_, len1, len2);
396 CompareOutputArrayWriter* array_writer_;
402 // Wraps raw n-elements line_ends array as a list of n+1 lines. The last line
403 // never has terminating new line character.
404 class LineEndsWrapper {
406 explicit LineEndsWrapper(Handle<String> string)
407 : ends_array_(String::CalculateLineEnds(string, false)),
408 string_len_(string->length()) {
411 return ends_array_->length() + 1;
413 // Returns start for any line including start of the imaginary line after
415 int GetLineStart(int index) {
419 return GetLineEnd(index - 1);
422 int GetLineEnd(int index) {
423 if (index == ends_array_->length()) {
424 // End of the last line is always an end of the whole string.
425 // If the string ends with a new line character, the last line is an
426 // empty string after this character.
429 return GetPosAfterNewLine(index);
434 Handle<FixedArray> ends_array_;
437 int GetPosAfterNewLine(int index) {
438 return Smi::cast(ends_array_->get(index))->value() + 1;
443 // Represents 2 strings as 2 arrays of lines.
444 class LineArrayCompareInput : public SubrangableInput {
446 LineArrayCompareInput(Handle<String> s1, Handle<String> s2,
447 LineEndsWrapper line_ends1, LineEndsWrapper line_ends2)
448 : s1_(s1), s2_(s2), line_ends1_(line_ends1),
449 line_ends2_(line_ends2),
450 subrange_offset1_(0), subrange_offset2_(0),
451 subrange_len1_(line_ends1_.length()),
452 subrange_len2_(line_ends2_.length()) {
455 return subrange_len1_;
458 return subrange_len2_;
460 bool Equals(int index1, int index2) {
461 index1 += subrange_offset1_;
462 index2 += subrange_offset2_;
464 int line_start1 = line_ends1_.GetLineStart(index1);
465 int line_start2 = line_ends2_.GetLineStart(index2);
466 int line_end1 = line_ends1_.GetLineEnd(index1);
467 int line_end2 = line_ends2_.GetLineEnd(index2);
468 int len1 = line_end1 - line_start1;
469 int len2 = line_end2 - line_start2;
473 return CompareSubstrings(s1_, line_start1, s2_, line_start2,
476 void SetSubrange1(int offset, int len) {
477 subrange_offset1_ = offset;
478 subrange_len1_ = len;
480 void SetSubrange2(int offset, int len) {
481 subrange_offset2_ = offset;
482 subrange_len2_ = len;
488 LineEndsWrapper line_ends1_;
489 LineEndsWrapper line_ends2_;
490 int subrange_offset1_;
491 int subrange_offset2_;
497 // Stores compare result in JSArray. For each chunk tries to conduct
498 // a fine-grained nested diff token-wise.
499 class TokenizingLineArrayCompareOutput : public SubrangableOutput {
501 TokenizingLineArrayCompareOutput(LineEndsWrapper line_ends1,
502 LineEndsWrapper line_ends2,
503 Handle<String> s1, Handle<String> s2)
504 : array_writer_(s1->GetIsolate()),
505 line_ends1_(line_ends1), line_ends2_(line_ends2), s1_(s1), s2_(s2),
506 subrange_offset1_(0), subrange_offset2_(0) {
509 void AddChunk(int line_pos1, int line_pos2, int line_len1, int line_len2) {
510 line_pos1 += subrange_offset1_;
511 line_pos2 += subrange_offset2_;
513 int char_pos1 = line_ends1_.GetLineStart(line_pos1);
514 int char_pos2 = line_ends2_.GetLineStart(line_pos2);
515 int char_len1 = line_ends1_.GetLineStart(line_pos1 + line_len1) - char_pos1;
516 int char_len2 = line_ends2_.GetLineStart(line_pos2 + line_len2) - char_pos2;
518 if (char_len1 < CHUNK_LEN_LIMIT && char_len2 < CHUNK_LEN_LIMIT) {
519 // Chunk is small enough to conduct a nested token-level diff.
520 HandleScope subTaskScope(s1_->GetIsolate());
522 TokensCompareInput tokens_input(s1_, char_pos1, char_len1,
523 s2_, char_pos2, char_len2);
524 TokensCompareOutput tokens_output(&array_writer_, char_pos1,
527 Comparator::CalculateDifference(&tokens_input, &tokens_output);
529 array_writer_.WriteChunk(char_pos1, char_pos2, char_len1, char_len2);
532 void SetSubrange1(int offset, int len) {
533 subrange_offset1_ = offset;
535 void SetSubrange2(int offset, int len) {
536 subrange_offset2_ = offset;
539 Handle<JSArray> GetResult() {
540 return array_writer_.GetResult();
544 static const int CHUNK_LEN_LIMIT = 800;
546 CompareOutputArrayWriter array_writer_;
547 LineEndsWrapper line_ends1_;
548 LineEndsWrapper line_ends2_;
551 int subrange_offset1_;
552 int subrange_offset2_;
556 Handle<JSArray> LiveEdit::CompareStrings(Handle<String> s1,
558 s1 = String::Flatten(s1);
559 s2 = String::Flatten(s2);
561 LineEndsWrapper line_ends1(s1);
562 LineEndsWrapper line_ends2(s2);
564 LineArrayCompareInput input(s1, s2, line_ends1, line_ends2);
565 TokenizingLineArrayCompareOutput output(line_ends1, line_ends2, s1, s2);
567 NarrowDownInput(&input, &output);
569 Comparator::CalculateDifference(&input, &output);
571 return output.GetResult();
575 // Unwraps JSValue object, returning its field "value"
576 static Handle<Object> UnwrapJSValue(Handle<JSValue> jsValue) {
577 return Handle<Object>(jsValue->value(), jsValue->GetIsolate());
581 // Wraps any object into a OpaqueReference, that will hide the object
583 static Handle<JSValue> WrapInJSValue(Handle<HeapObject> object) {
584 Isolate* isolate = object->GetIsolate();
585 Handle<JSFunction> constructor = isolate->opaque_reference_function();
586 Handle<JSValue> result =
587 Handle<JSValue>::cast(isolate->factory()->NewJSObject(constructor));
588 result->set_value(*object);
593 static Handle<SharedFunctionInfo> UnwrapSharedFunctionInfoFromJSValue(
594 Handle<JSValue> jsValue) {
595 Object* shared = jsValue->value();
596 CHECK(shared->IsSharedFunctionInfo());
597 return Handle<SharedFunctionInfo>(SharedFunctionInfo::cast(shared));
601 static int GetArrayLength(Handle<JSArray> array) {
602 Object* length = array->length();
603 CHECK(length->IsSmi());
604 return Smi::cast(length)->value();
608 void FunctionInfoWrapper::SetInitialProperties(Handle<String> name,
610 int end_position, int param_num,
613 HandleScope scope(isolate());
614 this->SetField(kFunctionNameOffset_, name);
615 this->SetSmiValueField(kStartPositionOffset_, start_position);
616 this->SetSmiValueField(kEndPositionOffset_, end_position);
617 this->SetSmiValueField(kParamNumOffset_, param_num);
618 this->SetSmiValueField(kLiteralNumOffset_, literal_count);
619 this->SetSmiValueField(kParentIndexOffset_, parent_index);
623 void FunctionInfoWrapper::SetFunctionCode(Handle<Code> function_code,
624 Handle<HeapObject> code_scope_info) {
625 Handle<JSValue> code_wrapper = WrapInJSValue(function_code);
626 this->SetField(kCodeOffset_, code_wrapper);
628 Handle<JSValue> scope_wrapper = WrapInJSValue(code_scope_info);
629 this->SetField(kCodeScopeInfoOffset_, scope_wrapper);
633 void FunctionInfoWrapper::SetSharedFunctionInfo(
634 Handle<SharedFunctionInfo> info) {
635 Handle<JSValue> info_holder = WrapInJSValue(info);
636 this->SetField(kSharedFunctionInfoOffset_, info_holder);
640 Handle<Code> FunctionInfoWrapper::GetFunctionCode() {
641 Handle<Object> element = this->GetField(kCodeOffset_);
642 Handle<JSValue> value_wrapper = Handle<JSValue>::cast(element);
643 Handle<Object> raw_result = UnwrapJSValue(value_wrapper);
644 CHECK(raw_result->IsCode());
645 return Handle<Code>::cast(raw_result);
649 MaybeHandle<TypeFeedbackVector> FunctionInfoWrapper::GetFeedbackVector() {
650 Handle<Object> element = this->GetField(kSharedFunctionInfoOffset_);
651 if (element->IsJSValue()) {
652 Handle<JSValue> value_wrapper = Handle<JSValue>::cast(element);
653 Handle<Object> raw_result = UnwrapJSValue(value_wrapper);
654 Handle<SharedFunctionInfo> shared =
655 Handle<SharedFunctionInfo>::cast(raw_result);
656 return Handle<TypeFeedbackVector>(shared->feedback_vector(), isolate());
658 // Scripts may never have a SharedFunctionInfo created.
659 return MaybeHandle<TypeFeedbackVector>();
664 Handle<Object> FunctionInfoWrapper::GetCodeScopeInfo() {
665 Handle<Object> element = this->GetField(kCodeScopeInfoOffset_);
666 return UnwrapJSValue(Handle<JSValue>::cast(element));
670 void SharedInfoWrapper::SetProperties(Handle<String> name,
673 Handle<SharedFunctionInfo> info) {
674 HandleScope scope(isolate());
675 this->SetField(kFunctionNameOffset_, name);
676 Handle<JSValue> info_holder = WrapInJSValue(info);
677 this->SetField(kSharedInfoOffset_, info_holder);
678 this->SetSmiValueField(kStartPositionOffset_, start_position);
679 this->SetSmiValueField(kEndPositionOffset_, end_position);
683 Handle<SharedFunctionInfo> SharedInfoWrapper::GetInfo() {
684 Handle<Object> element = this->GetField(kSharedInfoOffset_);
685 Handle<JSValue> value_wrapper = Handle<JSValue>::cast(element);
686 return UnwrapSharedFunctionInfoFromJSValue(value_wrapper);
690 class FunctionInfoListener {
692 explicit FunctionInfoListener(Isolate* isolate) {
693 current_parent_index_ = -1;
695 result_ = isolate->factory()->NewJSArray(10);
698 void FunctionStarted(FunctionLiteral* fun) {
699 HandleScope scope(isolate());
700 FunctionInfoWrapper info = FunctionInfoWrapper::Create(isolate());
701 info.SetInitialProperties(fun->name(), fun->start_position(),
702 fun->end_position(), fun->parameter_count(),
703 fun->materialized_literal_count(),
704 current_parent_index_);
705 current_parent_index_ = len_;
706 SetElementSloppy(result_, len_, info.GetJSArray());
710 void FunctionDone() {
711 HandleScope scope(isolate());
712 FunctionInfoWrapper info =
713 FunctionInfoWrapper::cast(
715 isolate(), result_, current_parent_index_).ToHandleChecked());
716 current_parent_index_ = info.GetParentIndex();
719 // Saves only function code, because for a script function we
720 // may never create a SharedFunctionInfo object.
721 void FunctionCode(Handle<Code> function_code) {
722 FunctionInfoWrapper info =
723 FunctionInfoWrapper::cast(
725 isolate(), result_, current_parent_index_).ToHandleChecked());
726 info.SetFunctionCode(function_code,
727 Handle<HeapObject>(isolate()->heap()->null_value()));
730 // Saves full information about a function: its code, its scope info
731 // and a SharedFunctionInfo object.
732 void FunctionInfo(Handle<SharedFunctionInfo> shared, Scope* scope,
734 if (!shared->IsSharedFunctionInfo()) {
737 FunctionInfoWrapper info =
738 FunctionInfoWrapper::cast(
740 isolate(), result_, current_parent_index_).ToHandleChecked());
741 info.SetFunctionCode(Handle<Code>(shared->code()),
742 Handle<HeapObject>(shared->scope_info()));
743 info.SetSharedFunctionInfo(shared);
745 Handle<Object> scope_info_list = SerializeFunctionScope(scope, zone);
746 info.SetFunctionScopeInfo(scope_info_list);
749 Handle<JSArray> GetResult() { return result_; }
752 Isolate* isolate() const { return result_->GetIsolate(); }
754 Handle<Object> SerializeFunctionScope(Scope* scope, Zone* zone) {
755 Handle<JSArray> scope_info_list = isolate()->factory()->NewJSArray(10);
756 int scope_info_length = 0;
758 // Saves some description of scope. It stores name and indexes of
759 // variables in the whole scope chain. Null-named slots delimit
760 // scopes of this chain.
761 Scope* current_scope = scope;
762 while (current_scope != NULL) {
763 HandleScope handle_scope(isolate());
764 ZoneList<Variable*> stack_list(current_scope->StackLocalCount(), zone);
765 ZoneList<Variable*> context_list(
766 current_scope->ContextLocalCount(), zone);
767 current_scope->CollectStackAndContextLocals(&stack_list, &context_list);
768 context_list.Sort(&Variable::CompareIndex);
770 for (int i = 0; i < context_list.length(); i++) {
771 SetElementSloppy(scope_info_list,
773 context_list[i]->name());
778 Handle<Smi>(Smi::FromInt(context_list[i]->index()), isolate()));
781 SetElementSloppy(scope_info_list,
783 Handle<Object>(isolate()->heap()->null_value(),
787 current_scope = current_scope->outer_scope();
790 return scope_info_list;
793 Handle<JSArray> result_;
795 int current_parent_index_;
799 void LiveEdit::InitializeThreadLocal(Debug* debug) {
800 debug->thread_local_.frame_drop_mode_ = LiveEdit::FRAMES_UNTOUCHED;
804 bool LiveEdit::SetAfterBreakTarget(Debug* debug) {
806 Isolate* isolate = debug->isolate_;
807 switch (debug->thread_local_.frame_drop_mode_) {
808 case FRAMES_UNTOUCHED:
810 case FRAME_DROPPED_IN_IC_CALL:
811 // We must have been calling IC stub. Do not go there anymore.
812 code = isolate->builtins()->builtin(Builtins::kPlainReturn_LiveEdit);
814 case FRAME_DROPPED_IN_DEBUG_SLOT_CALL:
815 // Debug break slot stub does not return normally, instead it manually
816 // cleans the stack and jumps. We should patch the jump address.
817 code = isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit);
819 case FRAME_DROPPED_IN_DIRECT_CALL:
820 // Nothing to do, after_break_target is not used here.
822 case FRAME_DROPPED_IN_RETURN_CALL:
823 code = isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit);
825 case CURRENTLY_SET_MODE:
829 debug->after_break_target_ = code->entry();
834 MaybeHandle<JSArray> LiveEdit::GatherCompileInfo(Handle<Script> script,
835 Handle<String> source) {
836 Isolate* isolate = script->GetIsolate();
838 FunctionInfoListener listener(isolate);
839 Handle<Object> original_source =
840 Handle<Object>(script->source(), isolate);
841 script->set_source(*source);
842 isolate->set_active_function_info_listener(&listener);
845 // Creating verbose TryCatch from public API is currently the only way to
846 // force code save location. We do not use this the object directly.
847 v8::TryCatch try_catch;
848 try_catch.SetVerbose(true);
850 // A logical 'try' section.
851 Compiler::CompileForLiveEdit(script);
854 // A logical 'catch' section.
855 Handle<JSObject> rethrow_exception;
856 if (isolate->has_pending_exception()) {
857 Handle<Object> exception(isolate->pending_exception(), isolate);
858 MessageLocation message_location = isolate->GetMessageLocation();
860 isolate->clear_pending_message();
861 isolate->clear_pending_exception();
863 // If possible, copy positions from message object to exception object.
864 if (exception->IsJSObject() && !message_location.script().is_null()) {
865 rethrow_exception = Handle<JSObject>::cast(exception);
867 Factory* factory = isolate->factory();
868 Handle<String> start_pos_key = factory->InternalizeOneByteString(
869 STATIC_CHAR_VECTOR("startPosition"));
870 Handle<String> end_pos_key =
871 factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("endPosition"));
872 Handle<String> script_obj_key =
873 factory->InternalizeOneByteString(STATIC_CHAR_VECTOR("scriptObject"));
874 Handle<Smi> start_pos(
875 Smi::FromInt(message_location.start_pos()), isolate);
876 Handle<Smi> end_pos(Smi::FromInt(message_location.end_pos()), isolate);
877 Handle<JSObject> script_obj =
878 Script::GetWrapper(message_location.script());
879 Object::SetProperty(rethrow_exception, start_pos_key, start_pos, SLOPPY)
881 Object::SetProperty(rethrow_exception, end_pos_key, end_pos, SLOPPY)
883 Object::SetProperty(rethrow_exception, script_obj_key, script_obj, SLOPPY)
888 // A logical 'finally' section.
889 isolate->set_active_function_info_listener(NULL);
890 script->set_source(*original_source);
892 if (rethrow_exception.is_null()) {
893 return listener.GetResult();
895 return isolate->Throw<JSArray>(rethrow_exception);
900 void LiveEdit::WrapSharedFunctionInfos(Handle<JSArray> array) {
901 Isolate* isolate = array->GetIsolate();
902 HandleScope scope(isolate);
903 int len = GetArrayLength(array);
904 for (int i = 0; i < len; i++) {
905 Handle<SharedFunctionInfo> info(
906 SharedFunctionInfo::cast(
907 *Object::GetElement(isolate, array, i).ToHandleChecked()));
908 SharedInfoWrapper info_wrapper = SharedInfoWrapper::Create(isolate);
909 Handle<String> name_handle(String::cast(info->name()));
910 info_wrapper.SetProperties(name_handle, info->start_position(),
911 info->end_position(), info);
912 SetElementSloppy(array, i, info_wrapper.GetJSArray());
917 // Visitor that finds all references to a particular code object,
918 // including "CODE_TARGET" references in other code objects and replaces
920 class ReplacingVisitor : public ObjectVisitor {
922 explicit ReplacingVisitor(Code* original, Code* substitution)
923 : original_(original), substitution_(substitution) {
926 virtual void VisitPointers(Object** start, Object** end) {
927 for (Object** p = start; p < end; p++) {
928 if (*p == original_) {
934 virtual void VisitCodeEntry(Address entry) {
935 if (Code::GetObjectFromEntryAddress(entry) == original_) {
936 Address substitution_entry = substitution_->instruction_start();
937 Memory::Address_at(entry) = substitution_entry;
941 virtual void VisitCodeTarget(RelocInfo* rinfo) {
942 if (RelocInfo::IsCodeTarget(rinfo->rmode()) &&
943 Code::GetCodeFromTargetAddress(rinfo->target_address()) == original_) {
944 Address substitution_entry = substitution_->instruction_start();
945 rinfo->set_target_address(substitution_entry);
949 virtual void VisitDebugTarget(RelocInfo* rinfo) {
950 VisitCodeTarget(rinfo);
959 // Finds all references to original and replaces them with substitution.
960 static void ReplaceCodeObject(Handle<Code> original,
961 Handle<Code> substitution) {
962 // Perform a full GC in order to ensure that we are not in the middle of an
963 // incremental marking phase when we are replacing the code object.
964 // Since we are not in an incremental marking phase we can write pointers
965 // to code objects (that are never in new space) without worrying about
967 Heap* heap = original->GetHeap();
968 HeapIterator iterator(heap);
970 DCHECK(!heap->InNewSpace(*substitution));
972 ReplacingVisitor visitor(*original, *substitution);
974 // Iterate over all roots. Stack frames may have pointer into original code,
975 // so temporary replace the pointers with offset numbers
976 // in prologue/epilogue.
977 heap->IterateRoots(&visitor, VISIT_ALL);
979 // Now iterate over all pointers of all objects, including code_target
980 // implicit pointers.
981 for (HeapObject* obj = iterator.next(); obj != NULL; obj = iterator.next()) {
982 obj->Iterate(&visitor);
987 // Patch function literals.
988 // Name 'literals' is a misnomer. Rather it's a cache for complex object
989 // boilerplates and for a native context. We must clean cached values.
990 // Additionally we may need to allocate a new array if number of literals
994 static void PatchLiterals(FunctionInfoWrapper* compile_info_wrapper,
995 Handle<SharedFunctionInfo> shared_info,
997 int new_literal_count = compile_info_wrapper->GetLiteralCount();
998 if (new_literal_count > 0) {
999 new_literal_count += JSFunction::kLiteralsPrefixSize;
1001 int old_literal_count = shared_info->num_literals();
1003 if (old_literal_count == new_literal_count) {
1004 // If literal count didn't change, simply go over all functions
1005 // and clear literal arrays.
1006 ClearValuesVisitor visitor;
1007 IterateJSFunctions(shared_info, &visitor);
1009 // When literal count changes, we have to create new array instances.
1010 // Since we cannot create instances when iterating heap, we should first
1011 // collect all functions and fix their literal arrays.
1012 Handle<FixedArray> function_instances =
1013 CollectJSFunctions(shared_info, isolate);
1014 for (int i = 0; i < function_instances->length(); i++) {
1015 Handle<JSFunction> fun(JSFunction::cast(function_instances->get(i)));
1016 Handle<FixedArray> old_literals(fun->literals());
1017 Handle<FixedArray> new_literals =
1018 isolate->factory()->NewFixedArray(new_literal_count);
1019 if (new_literal_count > 0) {
1020 Handle<Context> native_context;
1021 if (old_literals->length() >
1022 JSFunction::kLiteralNativeContextIndex) {
1023 native_context = Handle<Context>(
1024 JSFunction::NativeContextFromLiterals(fun->literals()));
1026 native_context = Handle<Context>(fun->context()->native_context());
1028 new_literals->set(JSFunction::kLiteralNativeContextIndex,
1031 fun->set_literals(*new_literals);
1034 shared_info->set_num_literals(new_literal_count);
1039 // Iterates all function instances in the HEAP that refers to the
1040 // provided shared_info.
1041 template<typename Visitor>
1042 static void IterateJSFunctions(Handle<SharedFunctionInfo> shared_info,
1044 HeapIterator iterator(shared_info->GetHeap());
1045 for (HeapObject* obj = iterator.next(); obj != NULL;
1046 obj = iterator.next()) {
1047 if (obj->IsJSFunction()) {
1048 JSFunction* function = JSFunction::cast(obj);
1049 if (function->shared() == *shared_info) {
1050 visitor->visit(function);
1056 // Finds all instances of JSFunction that refers to the provided shared_info
1057 // and returns array with them.
1058 static Handle<FixedArray> CollectJSFunctions(
1059 Handle<SharedFunctionInfo> shared_info, Isolate* isolate) {
1060 CountVisitor count_visitor;
1061 count_visitor.count = 0;
1062 IterateJSFunctions(shared_info, &count_visitor);
1063 int size = count_visitor.count;
1065 Handle<FixedArray> result = isolate->factory()->NewFixedArray(size);
1067 CollectVisitor collect_visitor(result);
1068 IterateJSFunctions(shared_info, &collect_visitor);
1073 class ClearValuesVisitor {
1075 void visit(JSFunction* fun) {
1076 FixedArray* literals = fun->literals();
1077 int len = literals->length();
1078 for (int j = JSFunction::kLiteralsPrefixSize; j < len; j++) {
1079 literals->set_undefined(j);
1084 class CountVisitor {
1086 void visit(JSFunction* fun) {
1092 class CollectVisitor {
1094 explicit CollectVisitor(Handle<FixedArray> output)
1095 : m_output(output), m_pos(0) {}
1097 void visit(JSFunction* fun) {
1098 m_output->set(m_pos, fun);
1102 Handle<FixedArray> m_output;
1108 // Check whether the code is natural function code (not a lazy-compile stub
1110 static bool IsJSFunctionCode(Code* code) {
1111 return code->kind() == Code::FUNCTION;
1115 // Returns true if an instance of candidate were inlined into function's code.
1116 static bool IsInlined(JSFunction* function, SharedFunctionInfo* candidate) {
1117 DisallowHeapAllocation no_gc;
1119 if (function->code()->kind() != Code::OPTIMIZED_FUNCTION) return false;
1121 DeoptimizationInputData* data =
1122 DeoptimizationInputData::cast(function->code()->deoptimization_data());
1124 if (data == function->GetIsolate()->heap()->empty_fixed_array()) {
1128 FixedArray* literals = data->LiteralArray();
1130 int inlined_count = data->InlinedFunctionCount()->value();
1131 for (int i = 0; i < inlined_count; ++i) {
1132 JSFunction* inlined = JSFunction::cast(literals->get(i));
1133 if (inlined->shared() == candidate) return true;
1140 // Marks code that shares the same shared function info or has inlined
1141 // code that shares the same function info.
1142 class DependentFunctionMarker: public OptimizedFunctionVisitor {
1144 SharedFunctionInfo* shared_info_;
1147 explicit DependentFunctionMarker(SharedFunctionInfo* shared_info)
1148 : shared_info_(shared_info), found_(false) { }
1150 virtual void EnterContext(Context* context) { } // Don't care.
1151 virtual void LeaveContext(Context* context) { } // Don't care.
1152 virtual void VisitFunction(JSFunction* function) {
1153 // It should be guaranteed by the iterator that everything is optimized.
1154 DCHECK(function->code()->kind() == Code::OPTIMIZED_FUNCTION);
1155 if (shared_info_ == function->shared() ||
1156 IsInlined(function, shared_info_)) {
1157 // Mark the code for deoptimization.
1158 function->code()->set_marked_for_deoptimization(true);
1165 static void DeoptimizeDependentFunctions(SharedFunctionInfo* function_info) {
1166 DisallowHeapAllocation no_allocation;
1167 DependentFunctionMarker marker(function_info);
1168 // TODO(titzer): need to traverse all optimized code to find OSR code here.
1169 Deoptimizer::VisitAllOptimizedFunctions(function_info->GetIsolate(), &marker);
1171 if (marker.found_) {
1172 // Only go through with the deoptimization if something was found.
1173 Deoptimizer::DeoptimizeMarkedCode(function_info->GetIsolate());
1178 void LiveEdit::ReplaceFunctionCode(
1179 Handle<JSArray> new_compile_info_array,
1180 Handle<JSArray> shared_info_array) {
1181 Isolate* isolate = new_compile_info_array->GetIsolate();
1183 FunctionInfoWrapper compile_info_wrapper(new_compile_info_array);
1184 SharedInfoWrapper shared_info_wrapper(shared_info_array);
1186 Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
1188 if (IsJSFunctionCode(shared_info->code())) {
1189 Handle<Code> code = compile_info_wrapper.GetFunctionCode();
1190 ReplaceCodeObject(Handle<Code>(shared_info->code()), code);
1191 Handle<Object> code_scope_info = compile_info_wrapper.GetCodeScopeInfo();
1192 if (code_scope_info->IsFixedArray()) {
1193 shared_info->set_scope_info(ScopeInfo::cast(*code_scope_info));
1195 shared_info->DisableOptimization(kLiveEdit);
1196 // Update the type feedback vector, if needed.
1197 MaybeHandle<TypeFeedbackVector> feedback_vector =
1198 compile_info_wrapper.GetFeedbackVector();
1199 if (!feedback_vector.is_null()) {
1200 shared_info->set_feedback_vector(*feedback_vector.ToHandleChecked());
1204 if (shared_info->debug_info()->IsDebugInfo()) {
1205 Handle<DebugInfo> debug_info(DebugInfo::cast(shared_info->debug_info()));
1206 Handle<Code> new_original_code =
1207 isolate->factory()->CopyCode(compile_info_wrapper.GetFunctionCode());
1208 debug_info->set_original_code(*new_original_code);
1211 int start_position = compile_info_wrapper.GetStartPosition();
1212 int end_position = compile_info_wrapper.GetEndPosition();
1213 shared_info->set_start_position(start_position);
1214 shared_info->set_end_position(end_position);
1216 LiteralFixer::PatchLiterals(&compile_info_wrapper, shared_info, isolate);
1218 shared_info->set_construct_stub(
1219 isolate->builtins()->builtin(Builtins::kJSConstructStubGeneric));
1221 DeoptimizeDependentFunctions(*shared_info);
1222 isolate->compilation_cache()->Remove(shared_info);
1226 void LiveEdit::FunctionSourceUpdated(Handle<JSArray> shared_info_array) {
1227 SharedInfoWrapper shared_info_wrapper(shared_info_array);
1228 Handle<SharedFunctionInfo> shared_info = shared_info_wrapper.GetInfo();
1230 DeoptimizeDependentFunctions(*shared_info);
1231 shared_info_array->GetIsolate()->compilation_cache()->Remove(shared_info);
1235 void LiveEdit::SetFunctionScript(Handle<JSValue> function_wrapper,
1236 Handle<Object> script_handle) {
1237 Handle<SharedFunctionInfo> shared_info =
1238 UnwrapSharedFunctionInfoFromJSValue(function_wrapper);
1239 CHECK(script_handle->IsScript() || script_handle->IsUndefined());
1240 shared_info->set_script(*script_handle);
1241 shared_info->DisableOptimization(kLiveEdit);
1243 function_wrapper->GetIsolate()->compilation_cache()->Remove(shared_info);
1247 // For a script text change (defined as position_change_array), translates
1248 // position in unchanged text to position in changed text.
1249 // Text change is a set of non-overlapping regions in text, that have changed
1250 // their contents and length. It is specified as array of groups of 3 numbers:
1251 // (change_begin, change_end, change_end_new_position).
1252 // Each group describes a change in text; groups are sorted by change_begin.
1253 // Only position in text beyond any changes may be successfully translated.
1254 // If a positions is inside some region that changed, result is currently
1256 static int TranslatePosition(int original_position,
1257 Handle<JSArray> position_change_array) {
1258 int position_diff = 0;
1259 int array_len = GetArrayLength(position_change_array);
1260 Isolate* isolate = position_change_array->GetIsolate();
1261 // TODO(635): binary search may be used here
1262 for (int i = 0; i < array_len; i += 3) {
1263 HandleScope scope(isolate);
1264 Handle<Object> element = Object::GetElement(
1265 isolate, position_change_array, i).ToHandleChecked();
1266 CHECK(element->IsSmi());
1267 int chunk_start = Handle<Smi>::cast(element)->value();
1268 if (original_position < chunk_start) {
1271 element = Object::GetElement(
1272 isolate, position_change_array, i + 1).ToHandleChecked();
1273 CHECK(element->IsSmi());
1274 int chunk_end = Handle<Smi>::cast(element)->value();
1275 // Position mustn't be inside a chunk.
1276 DCHECK(original_position >= chunk_end);
1277 element = Object::GetElement(
1278 isolate, position_change_array, i + 2).ToHandleChecked();
1279 CHECK(element->IsSmi());
1280 int chunk_changed_end = Handle<Smi>::cast(element)->value();
1281 position_diff = chunk_changed_end - chunk_end;
1284 return original_position + position_diff;
1288 // Auto-growing buffer for writing relocation info code section. This buffer
1289 // is a simplified version of buffer from Assembler. Unlike Assembler, this
1290 // class is platform-independent and it works without dealing with instructions.
1291 // As specified by RelocInfo format, the buffer is filled in reversed order:
1292 // from upper to lower addresses.
1293 // It uses NewArray/DeleteArray for memory management.
1294 class RelocInfoBuffer {
1296 RelocInfoBuffer(int buffer_initial_capicity, byte* pc) {
1297 buffer_size_ = buffer_initial_capicity + kBufferGap;
1298 buffer_ = NewArray<byte>(buffer_size_);
1300 reloc_info_writer_.Reposition(buffer_ + buffer_size_, pc);
1302 ~RelocInfoBuffer() {
1303 DeleteArray(buffer_);
1306 // As specified by RelocInfo format, the buffer is filled in reversed order:
1307 // from upper to lower addresses.
1308 void Write(const RelocInfo* rinfo) {
1309 if (buffer_ + kBufferGap >= reloc_info_writer_.pos()) {
1312 reloc_info_writer_.Write(rinfo);
1315 Vector<byte> GetResult() {
1316 // Return the bytes from pos up to end of buffer.
1318 static_cast<int>((buffer_ + buffer_size_) - reloc_info_writer_.pos());
1319 return Vector<byte>(reloc_info_writer_.pos(), result_size);
1324 // Compute new buffer size.
1325 int new_buffer_size;
1326 if (buffer_size_ < 2 * KB) {
1327 new_buffer_size = 4 * KB;
1329 new_buffer_size = 2 * buffer_size_;
1331 // Some internal data structures overflow for very large buffers,
1332 // they must ensure that kMaximalBufferSize is not too large.
1333 if (new_buffer_size > kMaximalBufferSize) {
1334 V8::FatalProcessOutOfMemory("RelocInfoBuffer::GrowBuffer");
1337 // Set up new buffer.
1338 byte* new_buffer = NewArray<byte>(new_buffer_size);
1341 int curently_used_size =
1342 static_cast<int>(buffer_ + buffer_size_ - reloc_info_writer_.pos());
1343 MemMove(new_buffer + new_buffer_size - curently_used_size,
1344 reloc_info_writer_.pos(), curently_used_size);
1346 reloc_info_writer_.Reposition(
1347 new_buffer + new_buffer_size - curently_used_size,
1348 reloc_info_writer_.last_pc());
1350 DeleteArray(buffer_);
1351 buffer_ = new_buffer;
1352 buffer_size_ = new_buffer_size;
1355 RelocInfoWriter reloc_info_writer_;
1359 static const int kBufferGap = RelocInfoWriter::kMaxSize;
1360 static const int kMaximalBufferSize = 512*MB;
1364 // Patch positions in code (changes relocation info section) and possibly
1365 // returns new instance of code.
1366 static Handle<Code> PatchPositionsInCode(
1368 Handle<JSArray> position_change_array) {
1369 Isolate* isolate = code->GetIsolate();
1371 RelocInfoBuffer buffer_writer(code->relocation_size(),
1372 code->instruction_start());
1375 for (RelocIterator it(*code); !it.done(); it.next()) {
1376 RelocInfo* rinfo = it.rinfo();
1377 if (RelocInfo::IsPosition(rinfo->rmode())) {
1378 int position = static_cast<int>(rinfo->data());
1379 int new_position = TranslatePosition(position,
1380 position_change_array);
1381 if (position != new_position) {
1382 RelocInfo info_copy(rinfo->pc(), rinfo->rmode(), new_position, NULL);
1383 buffer_writer.Write(&info_copy);
1387 if (RelocInfo::IsRealRelocMode(rinfo->rmode())) {
1388 buffer_writer.Write(it.rinfo());
1393 Vector<byte> buffer = buffer_writer.GetResult();
1395 if (buffer.length() == code->relocation_size()) {
1396 // Simply patch relocation area of code.
1397 MemCopy(code->relocation_start(), buffer.start(), buffer.length());
1400 // Relocation info section now has different size. We cannot simply
1401 // rewrite it inside code object. Instead we have to create a new
1403 Handle<Code> result(isolate->factory()->CopyCode(code, buffer));
1409 void LiveEdit::PatchFunctionPositions(Handle<JSArray> shared_info_array,
1410 Handle<JSArray> position_change_array) {
1411 SharedInfoWrapper shared_info_wrapper(shared_info_array);
1412 Handle<SharedFunctionInfo> info = shared_info_wrapper.GetInfo();
1414 int old_function_start = info->start_position();
1415 int new_function_start = TranslatePosition(old_function_start,
1416 position_change_array);
1417 int new_function_end = TranslatePosition(info->end_position(),
1418 position_change_array);
1419 int new_function_token_pos =
1420 TranslatePosition(info->function_token_position(), position_change_array);
1422 info->set_start_position(new_function_start);
1423 info->set_end_position(new_function_end);
1424 info->set_function_token_position(new_function_token_pos);
1426 if (IsJSFunctionCode(info->code())) {
1427 // Patch relocation info section of the code.
1428 Handle<Code> patched_code = PatchPositionsInCode(Handle<Code>(info->code()),
1429 position_change_array);
1430 if (*patched_code != info->code()) {
1431 // Replace all references to the code across the heap. In particular,
1432 // some stubs may refer to this code and this code may be being executed
1433 // on stack (it is safe to substitute the code object on stack, because
1434 // we only change the structure of rinfo and leave instructions
1436 ReplaceCodeObject(Handle<Code>(info->code()), patched_code);
1442 static Handle<Script> CreateScriptCopy(Handle<Script> original) {
1443 Isolate* isolate = original->GetIsolate();
1445 Handle<String> original_source(String::cast(original->source()));
1446 Handle<Script> copy = isolate->factory()->NewScript(original_source);
1448 copy->set_name(original->name());
1449 copy->set_line_offset(original->line_offset());
1450 copy->set_column_offset(original->column_offset());
1451 copy->set_type(original->type());
1452 copy->set_context_data(original->context_data());
1453 copy->set_eval_from_shared(original->eval_from_shared());
1454 copy->set_eval_from_instructions_offset(
1455 original->eval_from_instructions_offset());
1457 // Copy all the flags, but clear compilation state.
1458 copy->set_flags(original->flags());
1459 copy->set_compilation_state(Script::COMPILATION_STATE_INITIAL);
1465 Handle<Object> LiveEdit::ChangeScriptSource(Handle<Script> original_script,
1466 Handle<String> new_source,
1467 Handle<Object> old_script_name) {
1468 Isolate* isolate = original_script->GetIsolate();
1469 Handle<Object> old_script_object;
1470 if (old_script_name->IsString()) {
1471 Handle<Script> old_script = CreateScriptCopy(original_script);
1472 old_script->set_name(String::cast(*old_script_name));
1473 old_script_object = old_script;
1474 isolate->debug()->OnAfterCompile(old_script);
1476 old_script_object = isolate->factory()->null_value();
1479 original_script->set_source(*new_source);
1481 // Drop line ends so that they will be recalculated.
1482 original_script->set_line_ends(isolate->heap()->undefined_value());
1484 return old_script_object;
1489 void LiveEdit::ReplaceRefToNestedFunction(
1490 Handle<JSValue> parent_function_wrapper,
1491 Handle<JSValue> orig_function_wrapper,
1492 Handle<JSValue> subst_function_wrapper) {
1494 Handle<SharedFunctionInfo> parent_shared =
1495 UnwrapSharedFunctionInfoFromJSValue(parent_function_wrapper);
1496 Handle<SharedFunctionInfo> orig_shared =
1497 UnwrapSharedFunctionInfoFromJSValue(orig_function_wrapper);
1498 Handle<SharedFunctionInfo> subst_shared =
1499 UnwrapSharedFunctionInfoFromJSValue(subst_function_wrapper);
1501 for (RelocIterator it(parent_shared->code()); !it.done(); it.next()) {
1502 if (it.rinfo()->rmode() == RelocInfo::EMBEDDED_OBJECT) {
1503 if (it.rinfo()->target_object() == *orig_shared) {
1504 it.rinfo()->set_target_object(*subst_shared);
1511 // Check an activation against list of functions. If there is a function
1512 // that matches, its status in result array is changed to status argument value.
1513 static bool CheckActivation(Handle<JSArray> shared_info_array,
1514 Handle<JSArray> result,
1516 LiveEdit::FunctionPatchabilityStatus status) {
1517 if (!frame->is_java_script()) return false;
1519 Handle<JSFunction> function(JavaScriptFrame::cast(frame)->function());
1521 Isolate* isolate = shared_info_array->GetIsolate();
1522 int len = GetArrayLength(shared_info_array);
1523 for (int i = 0; i < len; i++) {
1524 HandleScope scope(isolate);
1525 Handle<Object> element =
1526 Object::GetElement(isolate, shared_info_array, i).ToHandleChecked();
1527 Handle<JSValue> jsvalue = Handle<JSValue>::cast(element);
1528 Handle<SharedFunctionInfo> shared =
1529 UnwrapSharedFunctionInfoFromJSValue(jsvalue);
1531 if (function->shared() == *shared || IsInlined(*function, *shared)) {
1532 SetElementSloppy(result, i, Handle<Smi>(Smi::FromInt(status), isolate));
1540 // Iterates over handler chain and removes all elements that are inside
1541 // frames being dropped.
1542 static bool FixTryCatchHandler(StackFrame* top_frame,
1543 StackFrame* bottom_frame) {
1544 Address* pointer_address =
1545 &Memory::Address_at(top_frame->isolate()->get_address_from_id(
1546 Isolate::kHandlerAddress));
1548 while (*pointer_address < top_frame->sp()) {
1549 pointer_address = &Memory::Address_at(*pointer_address);
1551 Address* above_frame_address = pointer_address;
1552 while (*pointer_address < bottom_frame->fp()) {
1553 pointer_address = &Memory::Address_at(*pointer_address);
1555 bool change = *above_frame_address != *pointer_address;
1556 *above_frame_address = *pointer_address;
1561 // Initializes an artificial stack frame. The data it contains is used for:
1562 // a. successful work of frame dropper code which eventually gets control,
1563 // b. being compatible with regular stack structure for various stack
1565 // Returns address of stack allocated pointer to restarted function,
1566 // the value that is called 'restarter_frame_function_pointer'. The value
1567 // at this address (possibly updated by GC) may be used later when preparing
1568 // 'step in' operation.
1569 // Frame structure (conforms InternalFrame structure):
1572 // -- function (slot is called "context")
1574 static Object** SetUpFrameDropperFrame(StackFrame* bottom_js_frame,
1575 Handle<Code> code) {
1576 DCHECK(bottom_js_frame->is_java_script());
1578 Address fp = bottom_js_frame->fp();
1580 // Move function pointer into "context" slot.
1581 Memory::Object_at(fp + StandardFrameConstants::kContextOffset) =
1582 Memory::Object_at(fp + JavaScriptFrameConstants::kFunctionOffset);
1584 Memory::Object_at(fp + InternalFrameConstants::kCodeOffset) = *code;
1585 Memory::Object_at(fp + StandardFrameConstants::kMarkerOffset) =
1586 Smi::FromInt(StackFrame::INTERNAL);
1588 return reinterpret_cast<Object**>(&Memory::Object_at(
1589 fp + StandardFrameConstants::kContextOffset));
1593 // Removes specified range of frames from stack. There may be 1 or more
1594 // frames in range. Anyway the bottom frame is restarted rather than dropped,
1595 // and therefore has to be a JavaScript frame.
1596 // Returns error message or NULL.
1597 static const char* DropFrames(Vector<StackFrame*> frames,
1598 int top_frame_index,
1599 int bottom_js_frame_index,
1600 LiveEdit::FrameDropMode* mode,
1601 Object*** restarter_frame_function_pointer) {
1602 if (!LiveEdit::kFrameDropperSupported) {
1603 return "Stack manipulations are not supported in this architecture.";
1606 StackFrame* pre_top_frame = frames[top_frame_index - 1];
1607 StackFrame* top_frame = frames[top_frame_index];
1608 StackFrame* bottom_js_frame = frames[bottom_js_frame_index];
1610 DCHECK(bottom_js_frame->is_java_script());
1612 // Check the nature of the top frame.
1613 Isolate* isolate = bottom_js_frame->isolate();
1614 Code* pre_top_frame_code = pre_top_frame->LookupCode();
1615 bool frame_has_padding = true;
1616 if (pre_top_frame_code->is_inline_cache_stub() &&
1617 pre_top_frame_code->is_debug_stub()) {
1618 // OK, we can drop inline cache calls.
1619 *mode = LiveEdit::FRAME_DROPPED_IN_IC_CALL;
1620 } else if (pre_top_frame_code ==
1621 isolate->builtins()->builtin(Builtins::kSlot_DebugBreak)) {
1622 // OK, we can drop debug break slot.
1623 *mode = LiveEdit::FRAME_DROPPED_IN_DEBUG_SLOT_CALL;
1624 } else if (pre_top_frame_code ==
1625 isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit)) {
1626 // OK, we can drop our own code.
1627 pre_top_frame = frames[top_frame_index - 2];
1628 top_frame = frames[top_frame_index - 1];
1629 *mode = LiveEdit::CURRENTLY_SET_MODE;
1630 frame_has_padding = false;
1631 } else if (pre_top_frame_code ==
1632 isolate->builtins()->builtin(Builtins::kReturn_DebugBreak)) {
1633 *mode = LiveEdit::FRAME_DROPPED_IN_RETURN_CALL;
1634 } else if (pre_top_frame_code->kind() == Code::STUB &&
1635 CodeStub::GetMajorKey(pre_top_frame_code) == CodeStub::CEntry) {
1636 // Entry from our unit tests on 'debugger' statement.
1637 // It's fine, we support this case.
1638 *mode = LiveEdit::FRAME_DROPPED_IN_DIRECT_CALL;
1639 // We don't have a padding from 'debugger' statement call.
1640 // Here the stub is CEntry, it's not debug-only and can't be padded.
1641 // If anyone would complain, a proxy padded stub could be added.
1642 frame_has_padding = false;
1643 } else if (pre_top_frame->type() == StackFrame::ARGUMENTS_ADAPTOR) {
1644 // This must be adaptor that remain from the frame dropping that
1645 // is still on stack. A frame dropper frame must be above it.
1646 DCHECK(frames[top_frame_index - 2]->LookupCode() ==
1647 isolate->builtins()->builtin(Builtins::kFrameDropper_LiveEdit));
1648 pre_top_frame = frames[top_frame_index - 3];
1649 top_frame = frames[top_frame_index - 2];
1650 *mode = LiveEdit::CURRENTLY_SET_MODE;
1651 frame_has_padding = false;
1653 return "Unknown structure of stack above changing function";
1656 Address unused_stack_top = top_frame->sp();
1657 int new_frame_size = LiveEdit::kFrameDropperFrameSize * kPointerSize;
1658 Address unused_stack_bottom = bottom_js_frame->fp()
1659 - new_frame_size + kPointerSize; // Bigger address end is exclusive.
1661 Address* top_frame_pc_address = top_frame->pc_address();
1663 // top_frame may be damaged below this point. Do not used it.
1664 DCHECK(!(top_frame = NULL));
1666 if (unused_stack_top > unused_stack_bottom) {
1667 if (frame_has_padding) {
1668 int shortage_bytes =
1669 static_cast<int>(unused_stack_top - unused_stack_bottom);
1671 Address padding_start = pre_top_frame->fp() -
1672 LiveEdit::kFrameDropperFrameSize * kPointerSize;
1674 Address padding_pointer = padding_start;
1675 Smi* padding_object = Smi::FromInt(LiveEdit::kFramePaddingValue);
1676 while (Memory::Object_at(padding_pointer) == padding_object) {
1677 padding_pointer -= kPointerSize;
1679 int padding_counter =
1680 Smi::cast(Memory::Object_at(padding_pointer))->value();
1681 if (padding_counter * kPointerSize < shortage_bytes) {
1682 return "Not enough space for frame dropper frame "
1683 "(even with padding frame)";
1685 Memory::Object_at(padding_pointer) =
1686 Smi::FromInt(padding_counter - shortage_bytes / kPointerSize);
1688 StackFrame* pre_pre_frame = frames[top_frame_index - 2];
1690 MemMove(padding_start + kPointerSize - shortage_bytes,
1691 padding_start + kPointerSize,
1692 LiveEdit::kFrameDropperFrameSize * kPointerSize);
1694 pre_top_frame->UpdateFp(pre_top_frame->fp() - shortage_bytes);
1695 pre_pre_frame->SetCallerFp(pre_top_frame->fp());
1696 unused_stack_top -= shortage_bytes;
1698 STATIC_ASSERT(sizeof(Address) == kPointerSize);
1699 top_frame_pc_address -= shortage_bytes / kPointerSize;
1701 return "Not enough space for frame dropper frame";
1705 // Committing now. After this point we should return only NULL value.
1707 FixTryCatchHandler(pre_top_frame, bottom_js_frame);
1708 // Make sure FixTryCatchHandler is idempotent.
1709 DCHECK(!FixTryCatchHandler(pre_top_frame, bottom_js_frame));
1711 Handle<Code> code = isolate->builtins()->FrameDropper_LiveEdit();
1712 *top_frame_pc_address = code->entry();
1713 pre_top_frame->SetCallerFp(bottom_js_frame->fp());
1715 *restarter_frame_function_pointer =
1716 SetUpFrameDropperFrame(bottom_js_frame, code);
1718 DCHECK((**restarter_frame_function_pointer)->IsJSFunction());
1720 for (Address a = unused_stack_top;
1721 a < unused_stack_bottom;
1722 a += kPointerSize) {
1723 Memory::Object_at(a) = Smi::FromInt(0);
1730 // Describes a set of call frames that execute any of listed functions.
1731 // Finding no such frames does not mean error.
1732 class MultipleFunctionTarget {
1734 MultipleFunctionTarget(Handle<JSArray> shared_info_array,
1735 Handle<JSArray> result)
1736 : m_shared_info_array(shared_info_array),
1738 bool MatchActivation(StackFrame* frame,
1739 LiveEdit::FunctionPatchabilityStatus status) {
1740 return CheckActivation(m_shared_info_array, m_result, frame, status);
1742 const char* GetNotFoundMessage() const {
1746 Handle<JSArray> m_shared_info_array;
1747 Handle<JSArray> m_result;
1751 // Drops all call frame matched by target and all frames above them.
1752 template <typename TARGET>
1753 static const char* DropActivationsInActiveThreadImpl(Isolate* isolate,
1754 TARGET& target, // NOLINT
1756 Debug* debug = isolate->debug();
1758 Vector<StackFrame*> frames = CreateStackMap(isolate, &zone);
1761 int top_frame_index = -1;
1762 int frame_index = 0;
1763 for (; frame_index < frames.length(); frame_index++) {
1764 StackFrame* frame = frames[frame_index];
1765 if (frame->id() == debug->break_frame_id()) {
1766 top_frame_index = frame_index;
1769 if (target.MatchActivation(
1770 frame, LiveEdit::FUNCTION_BLOCKED_UNDER_NATIVE_CODE)) {
1771 // We are still above break_frame. It is not a target frame,
1773 return "Debugger mark-up on stack is not found";
1777 if (top_frame_index == -1) {
1778 // We haven't found break frame, but no function is blocking us anyway.
1779 return target.GetNotFoundMessage();
1782 bool target_frame_found = false;
1783 int bottom_js_frame_index = top_frame_index;
1784 bool non_droppable_frame_found = false;
1785 LiveEdit::FunctionPatchabilityStatus non_droppable_reason;
1787 for (; frame_index < frames.length(); frame_index++) {
1788 StackFrame* frame = frames[frame_index];
1789 if (frame->is_exit()) {
1790 non_droppable_frame_found = true;
1791 non_droppable_reason = LiveEdit::FUNCTION_BLOCKED_UNDER_NATIVE_CODE;
1794 if (frame->is_java_script() &&
1795 JavaScriptFrame::cast(frame)->function()->shared()->is_generator()) {
1796 non_droppable_frame_found = true;
1797 non_droppable_reason = LiveEdit::FUNCTION_BLOCKED_UNDER_GENERATOR;
1800 if (target.MatchActivation(
1801 frame, LiveEdit::FUNCTION_BLOCKED_ON_ACTIVE_STACK)) {
1802 target_frame_found = true;
1803 bottom_js_frame_index = frame_index;
1807 if (non_droppable_frame_found) {
1808 // There is a C or generator frame on stack. We can't drop C frames, and we
1809 // can't restart generators. Check that there are no target frames below
1811 for (; frame_index < frames.length(); frame_index++) {
1812 StackFrame* frame = frames[frame_index];
1813 if (frame->is_java_script()) {
1814 if (target.MatchActivation(frame, non_droppable_reason)) {
1823 // We are in check-only mode.
1827 if (!target_frame_found) {
1829 return target.GetNotFoundMessage();
1832 LiveEdit::FrameDropMode drop_mode = LiveEdit::FRAMES_UNTOUCHED;
1833 Object** restarter_frame_function_pointer = NULL;
1834 const char* error_message = DropFrames(frames, top_frame_index,
1835 bottom_js_frame_index, &drop_mode,
1836 &restarter_frame_function_pointer);
1838 if (error_message != NULL) {
1839 return error_message;
1842 // Adjust break_frame after some frames has been dropped.
1843 StackFrame::Id new_id = StackFrame::NO_ID;
1844 for (int i = bottom_js_frame_index + 1; i < frames.length(); i++) {
1845 if (frames[i]->type() == StackFrame::JAVA_SCRIPT) {
1846 new_id = frames[i]->id();
1850 debug->FramesHaveBeenDropped(
1851 new_id, drop_mode, restarter_frame_function_pointer);
1856 // Fills result array with statuses of functions. Modifies the stack
1857 // removing all listed function if possible and if do_drop is true.
1858 static const char* DropActivationsInActiveThread(
1859 Handle<JSArray> shared_info_array, Handle<JSArray> result, bool do_drop) {
1860 MultipleFunctionTarget target(shared_info_array, result);
1861 Isolate* isolate = shared_info_array->GetIsolate();
1863 const char* message =
1864 DropActivationsInActiveThreadImpl(isolate, target, do_drop);
1869 int array_len = GetArrayLength(shared_info_array);
1871 // Replace "blocked on active" with "replaced on active" status.
1872 for (int i = 0; i < array_len; i++) {
1873 Handle<Object> obj =
1874 Object::GetElement(isolate, result, i).ToHandleChecked();
1875 if (*obj == Smi::FromInt(LiveEdit::FUNCTION_BLOCKED_ON_ACTIVE_STACK)) {
1876 Handle<Object> replaced(
1877 Smi::FromInt(LiveEdit::FUNCTION_REPLACED_ON_ACTIVE_STACK), isolate);
1878 SetElementSloppy(result, i, replaced);
1885 bool LiveEdit::FindActiveGenerators(Handle<FixedArray> shared_info_array,
1886 Handle<FixedArray> result,
1888 Isolate* isolate = shared_info_array->GetIsolate();
1889 bool found_suspended_activations = false;
1891 DCHECK_LE(len, result->length());
1893 FunctionPatchabilityStatus active = FUNCTION_BLOCKED_ACTIVE_GENERATOR;
1895 Heap* heap = isolate->heap();
1896 HeapIterator iterator(heap);
1897 HeapObject* obj = NULL;
1898 while ((obj = iterator.next()) != NULL) {
1899 if (!obj->IsJSGeneratorObject()) continue;
1901 JSGeneratorObject* gen = JSGeneratorObject::cast(obj);
1902 if (gen->is_closed()) continue;
1904 HandleScope scope(isolate);
1906 for (int i = 0; i < len; i++) {
1907 Handle<JSValue> jsvalue =
1908 Handle<JSValue>::cast(FixedArray::get(shared_info_array, i));
1909 Handle<SharedFunctionInfo> shared =
1910 UnwrapSharedFunctionInfoFromJSValue(jsvalue);
1912 if (gen->function()->shared() == *shared) {
1913 result->set(i, Smi::FromInt(active));
1914 found_suspended_activations = true;
1919 return found_suspended_activations;
1923 class InactiveThreadActivationsChecker : public ThreadVisitor {
1925 InactiveThreadActivationsChecker(Handle<JSArray> shared_info_array,
1926 Handle<JSArray> result)
1927 : shared_info_array_(shared_info_array), result_(result),
1928 has_blocked_functions_(false) {
1930 void VisitThread(Isolate* isolate, ThreadLocalTop* top) {
1931 for (StackFrameIterator it(isolate, top); !it.done(); it.Advance()) {
1932 has_blocked_functions_ |= CheckActivation(
1933 shared_info_array_, result_, it.frame(),
1934 LiveEdit::FUNCTION_BLOCKED_ON_OTHER_STACK);
1937 bool HasBlockedFunctions() {
1938 return has_blocked_functions_;
1942 Handle<JSArray> shared_info_array_;
1943 Handle<JSArray> result_;
1944 bool has_blocked_functions_;
1948 Handle<JSArray> LiveEdit::CheckAndDropActivations(
1949 Handle<JSArray> shared_info_array, bool do_drop) {
1950 Isolate* isolate = shared_info_array->GetIsolate();
1951 int len = GetArrayLength(shared_info_array);
1953 DCHECK(shared_info_array->HasFastElements());
1954 Handle<FixedArray> shared_info_array_elements(
1955 FixedArray::cast(shared_info_array->elements()));
1957 Handle<JSArray> result = isolate->factory()->NewJSArray(len);
1958 Handle<FixedArray> result_elements =
1959 JSObject::EnsureWritableFastElements(result);
1961 // Fill the default values.
1962 for (int i = 0; i < len; i++) {
1963 FunctionPatchabilityStatus status = FUNCTION_AVAILABLE_FOR_PATCH;
1964 result_elements->set(i, Smi::FromInt(status));
1967 // Scan the heap for active generators -- those that are either currently
1968 // running (as we wouldn't want to restart them, because we don't know where
1969 // to restart them from) or suspended. Fail if any one corresponds to the set
1970 // of functions being edited.
1971 if (FindActiveGenerators(shared_info_array_elements, result_elements, len)) {
1975 // Check inactive threads. Fail if some functions are blocked there.
1976 InactiveThreadActivationsChecker inactive_threads_checker(shared_info_array,
1978 isolate->thread_manager()->IterateArchivedThreads(
1979 &inactive_threads_checker);
1980 if (inactive_threads_checker.HasBlockedFunctions()) {
1984 // Try to drop activations from the current stack.
1985 const char* error_message =
1986 DropActivationsInActiveThread(shared_info_array, result, do_drop);
1987 if (error_message != NULL) {
1988 // Add error message as an array extra element.
1989 Handle<String> str =
1990 isolate->factory()->NewStringFromAsciiChecked(error_message);
1991 SetElementSloppy(result, len, str);
1997 // Describes a single callframe a target. Not finding this frame
1999 class SingleFrameTarget {
2001 explicit SingleFrameTarget(JavaScriptFrame* frame)
2003 m_saved_status(LiveEdit::FUNCTION_AVAILABLE_FOR_PATCH) {}
2005 bool MatchActivation(StackFrame* frame,
2006 LiveEdit::FunctionPatchabilityStatus status) {
2007 if (frame->fp() == m_frame->fp()) {
2008 m_saved_status = status;
2013 const char* GetNotFoundMessage() const {
2014 return "Failed to found requested frame";
2016 LiveEdit::FunctionPatchabilityStatus saved_status() {
2017 return m_saved_status;
2020 JavaScriptFrame* m_frame;
2021 LiveEdit::FunctionPatchabilityStatus m_saved_status;
2025 // Finds a drops required frame and all frames above.
2026 // Returns error message or NULL.
2027 const char* LiveEdit::RestartFrame(JavaScriptFrame* frame) {
2028 SingleFrameTarget target(frame);
2030 const char* result =
2031 DropActivationsInActiveThreadImpl(frame->isolate(), target, true);
2032 if (result != NULL) {
2035 if (target.saved_status() == LiveEdit::FUNCTION_BLOCKED_UNDER_NATIVE_CODE) {
2036 return "Function is blocked under native code";
2038 if (target.saved_status() == LiveEdit::FUNCTION_BLOCKED_UNDER_GENERATOR) {
2039 return "Function is blocked under a generator activation";
2045 LiveEditFunctionTracker::LiveEditFunctionTracker(Isolate* isolate,
2046 FunctionLiteral* fun)
2047 : isolate_(isolate) {
2048 if (isolate_->active_function_info_listener() != NULL) {
2049 isolate_->active_function_info_listener()->FunctionStarted(fun);
2054 LiveEditFunctionTracker::~LiveEditFunctionTracker() {
2055 if (isolate_->active_function_info_listener() != NULL) {
2056 isolate_->active_function_info_listener()->FunctionDone();
2061 void LiveEditFunctionTracker::RecordFunctionInfo(
2062 Handle<SharedFunctionInfo> info, FunctionLiteral* lit,
2064 if (isolate_->active_function_info_listener() != NULL) {
2065 isolate_->active_function_info_listener()->FunctionInfo(info, lit->scope(),
2071 void LiveEditFunctionTracker::RecordRootFunctionInfo(Handle<Code> code) {
2072 isolate_->active_function_info_listener()->FunctionCode(code);
2076 bool LiveEditFunctionTracker::IsActive(Isolate* isolate) {
2077 return isolate->active_function_info_listener() != NULL;
2080 } } // namespace v8::internal