v8  3.14.5(node0.10.28)
V8 is Google's open source JavaScript engine
 All Data Structures Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
frames-inl.h
Go to the documentation of this file.
1 // Copyright 2012 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_FRAMES_INL_H_
29 #define V8_FRAMES_INL_H_
30 
31 #include "frames.h"
32 #include "isolate.h"
33 #include "v8memory.h"
34 
35 #if V8_TARGET_ARCH_IA32
36 #include "ia32/frames-ia32.h"
37 #elif V8_TARGET_ARCH_X64
38 #include "x64/frames-x64.h"
39 #elif V8_TARGET_ARCH_ARM
40 #include "arm/frames-arm.h"
41 #elif V8_TARGET_ARCH_MIPS
42 #include "mips/frames-mips.h"
43 #else
44 #error Unsupported target architecture.
45 #endif
46 
47 namespace v8 {
48 namespace internal {
49 
50 
51 inline Address StackHandler::address() const {
52  return reinterpret_cast<Address>(const_cast<StackHandler*>(this));
53 }
54 
55 
56 inline StackHandler* StackHandler::next() const {
57  const int offset = StackHandlerConstants::kNextOffset;
58  return FromAddress(Memory::Address_at(address() + offset));
59 }
60 
61 
62 inline bool StackHandler::includes(Address address) const {
63  Address start = this->address();
65  return start <= address && address <= end;
66 }
67 
68 
69 inline void StackHandler::Iterate(ObjectVisitor* v, Code* holder) const {
70  v->VisitPointer(context_address());
71  v->VisitPointer(code_address());
72 }
73 
74 
75 inline StackHandler* StackHandler::FromAddress(Address address) {
76  return reinterpret_cast<StackHandler*>(address);
77 }
78 
79 
80 inline bool StackHandler::is_js_entry() const {
81  return kind() == JS_ENTRY;
82 }
83 
84 
85 inline bool StackHandler::is_catch() const {
86  return kind() == CATCH;
87 }
88 
89 
90 inline bool StackHandler::is_finally() const {
91  return kind() == FINALLY;
92 }
93 
94 
95 inline StackHandler::Kind StackHandler::kind() const {
96  const int offset = StackHandlerConstants::kStateOffset;
97  return KindField::decode(Memory::unsigned_at(address() + offset));
98 }
99 
100 
101 inline Object** StackHandler::context_address() const {
102  const int offset = StackHandlerConstants::kContextOffset;
103  return reinterpret_cast<Object**>(address() + offset);
104 }
105 
106 
107 inline Object** StackHandler::code_address() const {
108  const int offset = StackHandlerConstants::kCodeOffset;
109  return reinterpret_cast<Object**>(address() + offset);
110 }
111 
112 
113 inline StackFrame::StackFrame(StackFrameIterator* iterator)
114  : iterator_(iterator), isolate_(iterator_->isolate()) {
115 }
116 
117 
118 inline StackHandler* StackFrame::top_handler() const {
119  return iterator_->handler();
120 }
121 
122 
123 inline Code* StackFrame::LookupCode() const {
124  return GetContainingCode(isolate(), pc());
125 }
126 
127 
128 inline Code* StackFrame::GetContainingCode(Isolate* isolate, Address pc) {
129  return isolate->inner_pointer_to_code_cache()->GetCacheEntry(pc)->code;
130 }
131 
132 
133 inline EntryFrame::EntryFrame(StackFrameIterator* iterator)
134  : StackFrame(iterator) {
135 }
136 
137 
138 inline EntryConstructFrame::EntryConstructFrame(StackFrameIterator* iterator)
139  : EntryFrame(iterator) {
140 }
141 
142 
143 inline ExitFrame::ExitFrame(StackFrameIterator* iterator)
144  : StackFrame(iterator) {
145 }
146 
147 
148 inline StandardFrame::StandardFrame(StackFrameIterator* iterator)
149  : StackFrame(iterator) {
150 }
151 
152 
153 inline Object* StandardFrame::GetExpression(int index) const {
155 }
156 
157 
158 inline void StandardFrame::SetExpression(int index, Object* value) {
159  Memory::Object_at(GetExpressionAddress(index)) = value;
160 }
161 
162 
164  const int offset = StandardFrameConstants::kContextOffset;
165  return Memory::Object_at(fp() + offset);
166 }
167 
168 
171 }
172 
173 
176 }
177 
178 
181 }
182 
183 
185  Object* marker =
188 }
189 
190 
192  Object* marker =
194  return marker == Smi::FromInt(StackFrame::CONSTRUCT);
195 }
196 
197 
198 inline JavaScriptFrame::JavaScriptFrame(StackFrameIterator* iterator)
199  : StandardFrame(iterator) {
200 }
201 
202 
204  int param_count = ComputeParametersCount();
205  ASSERT(-1 <= index && index < param_count);
206  int parameter_offset = (param_count - index - 1) * kPointerSize;
207  return caller_sp() + parameter_offset;
208 }
209 
210 
212  return Memory::Object_at(GetParameterSlot(index));
213 }
214 
215 
217  return GetParameter(-1);
218 }
219 
220 
222  Memory::Object_at(GetParameterSlot(-1)) = value;
223 }
224 
225 
228 }
229 
230 
232  Object* result = function_slot_object();
233  ASSERT(result->IsJSFunction());
234  return result;
235 }
236 
237 
238 inline OptimizedFrame::OptimizedFrame(StackFrameIterator* iterator)
239  : JavaScriptFrame(iterator) {
240 }
241 
242 
244  StackFrameIterator* iterator) : JavaScriptFrame(iterator) {
245 }
246 
247 
248 inline InternalFrame::InternalFrame(StackFrameIterator* iterator)
249  : StandardFrame(iterator) {
250 }
251 
252 
253 inline ConstructFrame::ConstructFrame(StackFrameIterator* iterator)
254  : InternalFrame(iterator) {
255 }
256 
257 
258 template<typename Iterator>
259 inline JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
260  Isolate* isolate)
261  : iterator_(isolate) {
262  if (!done()) Advance();
263 }
264 
265 
266 template<typename Iterator>
267 inline JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
268  Isolate* isolate, ThreadLocalTop* top)
269  : iterator_(isolate, top) {
270  if (!done()) Advance();
271 }
272 
273 
274 template<typename Iterator>
275 inline JavaScriptFrame* JavaScriptFrameIteratorTemp<Iterator>::frame() const {
276  // TODO(1233797): The frame hierarchy needs to change. It's
277  // problematic that we can't use the safe-cast operator to cast to
278  // the JavaScript frame type, because we may encounter arguments
279  // adaptor frames.
280  StackFrame* frame = iterator_.frame();
281  ASSERT(frame->is_java_script() || frame->is_arguments_adaptor());
282  return static_cast<JavaScriptFrame*>(frame);
283 }
284 
285 
286 template<typename Iterator>
287 JavaScriptFrameIteratorTemp<Iterator>::JavaScriptFrameIteratorTemp(
288  Isolate* isolate, StackFrame::Id id)
289  : iterator_(isolate) {
290  AdvanceToId(id);
291 }
292 
293 
294 template<typename Iterator>
295 void JavaScriptFrameIteratorTemp<Iterator>::Advance() {
296  do {
297  iterator_.Advance();
298  } while (!iterator_.done() && !iterator_.frame()->is_java_script());
299 }
300 
301 
302 template<typename Iterator>
303 void JavaScriptFrameIteratorTemp<Iterator>::AdvanceToArgumentsFrame() {
304  if (!frame()->has_adapted_arguments()) return;
305  iterator_.Advance();
306  ASSERT(iterator_.frame()->is_arguments_adaptor());
307 }
308 
309 
310 template<typename Iterator>
311 void JavaScriptFrameIteratorTemp<Iterator>::AdvanceToId(StackFrame::Id id) {
312  while (!done()) {
313  Advance();
314  if (frame()->id() == id) return;
315  }
316 }
317 
318 
319 template<typename Iterator>
320 void JavaScriptFrameIteratorTemp<Iterator>::Reset() {
321  iterator_.Reset();
322  if (!done()) Advance();
323 }
324 
325 
326 } } // namespace v8::internal
327 
328 #endif // V8_FRAMES_INL_H_
byte * Address
Definition: globals.h:157
Object * context() const
Definition: frames-inl.h:163
Object * function() const
Definition: frames-inl.h:231
static Object *& Object_at(Address addr)
Definition: v8memory.h:75
static Smi * FromInt(int value)
Definition: objects-inl.h:981
Address GetParameterSlot(int index) const
Definition: frames-inl.h:203
static bool IsArgumentsAdaptorFrame(Address fp)
Definition: frames-inl.h:184
Address GetExpressionAddress(int n) const
Definition: frames.cc:569
Address caller_fp() const
Definition: frames-inl.h:169
Object * GetExpression(int index) const
Definition: frames-inl.h:153
#define ASSERT(condition)
Definition: checks.h:270
ArgumentsAdaptorFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:243
int ComputeParametersCount() const
Definition: frames.h:499
Object * receiver() const
Definition: frames-inl.h:216
HANDLE HANDLE LPSTACKFRAME64 StackFrame
static Address ComputePCAddress(Address fp)
Definition: frames-inl.h:179
const int kPointerSize
Definition: globals.h:220
void SetExpression(int index, Object *value)
Definition: frames-inl.h:158
static Address & Address_at(Address addr)
Definition: v8memory.h:71
const Register pc
void set_receiver(Object *value)
Definition: frames-inl.h:221
Address caller_pc() const
Definition: frames-inl.h:174
EntryConstructFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:138
EntryFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:133
OptimizedFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:238
ConstructFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:253
JavaScriptFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:198
InternalFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:248
static bool IsConstructFrame(Address fp)
Definition: frames-inl.h:191
static unsigned & unsigned_at(Address addr)
Definition: v8memory.h:63
ExitFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:143
StandardFrame(StackFrameIterator *iterator)
Definition: frames-inl.h:148
const Register fp
Object * GetParameter(int index) const
Definition: frames-inl.h:211
Definition: frames.h:309
bool has_adapted_arguments() const
Definition: frames-inl.h:226