liveedit.h revision b0fe1620dcb4135ac3ab2d66ff93072373911299 
1// Copyright 2010 the V8 project authors. All rights reserved.
2// Redistribution and use in source and binary forms, with or without
3// modification, are permitted provided that the following conditions are
4// met:
5//
6//     * Redistributions of source code must retain the above copyright
7//       notice, this list of conditions and the following disclaimer.
8//     * Redistributions in binary form must reproduce the above
9//       copyright notice, this list of conditions and the following
10//       disclaimer in the documentation and/or other materials provided
11//       with the distribution.
12//     * Neither the name of Google Inc. nor the names of its
13//       contributors may be used to endorse or promote products derived
14//       from this software without specific prior written permission.
15//
16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
27
28#ifndef V8_LIVEEDIT_H_
29#define V8_LIVEEDIT_H_
30
31
32
33// Live Edit feature implementation.
34// User should be able to change script on already running VM. This feature
35// matches hot swap features in other frameworks.
36//
37// The basic use-case is when user spots some mistake in function body
38// from debugger and wishes to change the algorithm without restart.
39//
40// A single change always has a form of a simple replacement (in pseudo-code):
41//   script.source[positions, positions+length] = new_string;
42// Implementation first determines, which function's body includes this
43// change area. Then both old and new versions of script are fully compiled
44// in order to analyze, whether the function changed its outer scope
45// expectations (or number of parameters). If it didn't, function's code is
46// patched with a newly compiled code. If it did change, enclosing function
47// gets patched. All inner functions are left untouched, whatever happened
48// to them in a new script version. However, new version of code will
49// instantiate newly compiled functions.
50
51
52#include "compiler.h"
53
54namespace v8 {
55namespace internal {
56
57// This class collects some specific information on structure of functions
58// in a particular script. It gets called from compiler all the time, but
59// actually records any data only when liveedit operation is in process;
60// in any other time this class is very cheap.
61//
62// The primary interest of the Tracker is to record function scope structures
63// in order to analyze whether function code maybe safely patched (with new
64// code successfully reading existing data from function scopes). The Tracker
65// also collects compiled function codes.
66class LiveEditFunctionTracker {
67 public:
68  explicit LiveEditFunctionTracker(FunctionLiteral* fun);
69  ~LiveEditFunctionTracker();
70  void RecordFunctionInfo(Handle<SharedFunctionInfo> info,
71                          FunctionLiteral* lit);
72  void RecordRootFunctionInfo(Handle<Code> code);
73
74  static bool IsActive();
75};
76
77#ifdef ENABLE_DEBUGGER_SUPPORT
78
79class LiveEdit : AllStatic {
80 public:
81  static JSArray* GatherCompileInfo(Handle<Script> script,
82                                    Handle<String> source);
83
84  static void WrapSharedFunctionInfos(Handle<JSArray> array);
85
86  MUST_USE_RESULT static MaybeObject* ReplaceFunctionCode(
87      Handle<JSArray> new_compile_info_array,
88      Handle<JSArray> shared_info_array);
89
90  static MaybeObject* FunctionSourceUpdated(Handle<JSArray> shared_info_array);
91
92  // Updates script field in FunctionSharedInfo.
93  static void SetFunctionScript(Handle<JSValue> function_wrapper,
94                                Handle<Object> script_handle);
95
96  MUST_USE_RESULT static MaybeObject* PatchFunctionPositions(
97      Handle<JSArray> shared_info_array, Handle<JSArray> position_change_array);
98
99  // For a script updates its source field. If old_script_name is provided
100  // (i.e. is a String), also creates a copy of the script with its original
101  // source and sends notification to debugger.
102  static Object* ChangeScriptSource(Handle<Script> original_script,
103                                    Handle<String> new_source,
104                                    Handle<Object> old_script_name);
105
106  // In a code of a parent function replaces original function as embedded
107  // object with a substitution one.
108  static void ReplaceRefToNestedFunction(Handle<JSValue> parent_function_shared,
109                                         Handle<JSValue> orig_function_shared,
110                                         Handle<JSValue> subst_function_shared);
111
112  // Checks listed functions on stack and return array with corresponding
113  // FunctionPatchabilityStatus statuses; extra array element may
114  // contain general error message. Modifies the current stack and
115  // has restart the lowest found frames and drops all other frames above
116  // if possible and if do_drop is true.
117  static Handle<JSArray> CheckAndDropActivations(
118      Handle<JSArray> shared_info_array, bool do_drop);
119
120  // A copy of this is in liveedit-debugger.js.
121  enum FunctionPatchabilityStatus {
122    FUNCTION_AVAILABLE_FOR_PATCH = 1,
123    FUNCTION_BLOCKED_ON_ACTIVE_STACK = 2,
124    FUNCTION_BLOCKED_ON_OTHER_STACK = 3,
125    FUNCTION_BLOCKED_UNDER_NATIVE_CODE = 4,
126    FUNCTION_REPLACED_ON_ACTIVE_STACK = 5
127  };
128
129  // Compares 2 strings line-by-line and returns diff in form of array of
130  // triplets (pos1, pos1_end, pos2_end) describing list of diff chunks.
131  static Handle<JSArray> CompareStringsLinewise(Handle<String> s1,
132                                                Handle<String> s2);
133};
134
135
136// A general-purpose comparator between 2 arrays.
137class Comparator {
138 public:
139
140  // Holds 2 arrays of some elements allowing to compare any pair of
141  // element from the first array and element from the second array.
142  class Input {
143   public:
144    virtual int getLength1() = 0;
145    virtual int getLength2() = 0;
146    virtual bool equals(int index1, int index2) = 0;
147
148   protected:
149    virtual ~Input() {}
150  };
151
152  // Receives compare result as a series of chunks.
153  class Output {
154   public:
155    // Puts another chunk in result list. Note that technically speaking
156    // only 3 arguments actually needed with 4th being derivable.
157    virtual void AddChunk(int pos1, int pos2, int len1, int len2) = 0;
158
159   protected:
160    virtual ~Output() {}
161  };
162
163  // Finds the difference between 2 arrays of elements.
164  static void CalculateDifference(Input* input,
165                                  Output* result_writer);
166};
167
168#endif  // ENABLE_DEBUGGER_SUPPORT
169
170
171} }  // namespace v8::internal
172
173#endif /* V*_LIVEEDIT_H_ */
174