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.
4
5#include "src/v8.h"
6
7#include "src/ast.h"
8#include "src/base/bits.h"
9#include "src/deoptimizer.h"
10#include "src/frames-inl.h"
11#include "src/full-codegen.h"
12#include "src/heap/mark-compact.h"
13#include "src/safepoint-table.h"
14#include "src/scopeinfo.h"
15#include "src/string-stream.h"
16#include "src/vm-state-inl.h"
17
18namespace v8 {
19namespace internal {
20
21
22ReturnAddressLocationResolver
23    StackFrame::return_address_location_resolver_ = NULL;
24
25
26// Iterator that supports traversing the stack handlers of a
27// particular frame. Needs to know the top of the handler chain.
28class StackHandlerIterator BASE_EMBEDDED {
29 public:
30  StackHandlerIterator(const StackFrame* frame, StackHandler* handler)
31      : limit_(frame->fp()), handler_(handler) {
32    // Make sure the handler has already been unwound to this frame.
33    DCHECK(frame->sp() <= handler->address());
34  }
35
36  StackHandler* handler() const { return handler_; }
37
38  bool done() {
39    return handler_ == NULL || handler_->address() > limit_;
40  }
41  void Advance() {
42    DCHECK(!done());
43    handler_ = handler_->next();
44  }
45
46 private:
47  const Address limit_;
48  StackHandler* handler_;
49};
50
51
52// -------------------------------------------------------------------------
53
54
55#define INITIALIZE_SINGLETON(type, field) field##_(this),
56StackFrameIteratorBase::StackFrameIteratorBase(Isolate* isolate,
57                                               bool can_access_heap_objects)
58    : isolate_(isolate),
59      STACK_FRAME_TYPE_LIST(INITIALIZE_SINGLETON)
60      frame_(NULL), handler_(NULL),
61      can_access_heap_objects_(can_access_heap_objects) {
62}
63#undef INITIALIZE_SINGLETON
64
65
66StackFrameIterator::StackFrameIterator(Isolate* isolate)
67    : StackFrameIteratorBase(isolate, true) {
68  Reset(isolate->thread_local_top());
69}
70
71
72StackFrameIterator::StackFrameIterator(Isolate* isolate, ThreadLocalTop* t)
73    : StackFrameIteratorBase(isolate, true) {
74  Reset(t);
75}
76
77
78void StackFrameIterator::Advance() {
79  DCHECK(!done());
80  // Compute the state of the calling frame before restoring
81  // callee-saved registers and unwinding handlers. This allows the
82  // frame code that computes the caller state to access the top
83  // handler and the value of any callee-saved register if needed.
84  StackFrame::State state;
85  StackFrame::Type type = frame_->GetCallerState(&state);
86
87  // Unwind handlers corresponding to the current frame.
88  StackHandlerIterator it(frame_, handler_);
89  while (!it.done()) it.Advance();
90  handler_ = it.handler();
91
92  // Advance to the calling frame.
93  frame_ = SingletonFor(type, &state);
94
95  // When we're done iterating over the stack frames, the handler
96  // chain must have been completely unwound.
97  DCHECK(!done() || handler_ == NULL);
98}
99
100
101void StackFrameIterator::Reset(ThreadLocalTop* top) {
102  StackFrame::State state;
103  StackFrame::Type type = ExitFrame::GetStateForFramePointer(
104      Isolate::c_entry_fp(top), &state);
105  handler_ = StackHandler::FromAddress(Isolate::handler(top));
106  if (SingletonFor(type) == NULL) return;
107  frame_ = SingletonFor(type, &state);
108}
109
110
111StackFrame* StackFrameIteratorBase::SingletonFor(StackFrame::Type type,
112                                             StackFrame::State* state) {
113  if (type == StackFrame::NONE) return NULL;
114  StackFrame* result = SingletonFor(type);
115  DCHECK(result != NULL);
116  result->state_ = *state;
117  return result;
118}
119
120
121StackFrame* StackFrameIteratorBase::SingletonFor(StackFrame::Type type) {
122#define FRAME_TYPE_CASE(type, field) \
123  case StackFrame::type: result = &field##_; break;
124
125  StackFrame* result = NULL;
126  switch (type) {
127    case StackFrame::NONE: return NULL;
128    STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
129    default: break;
130  }
131  return result;
132
133#undef FRAME_TYPE_CASE
134}
135
136
137// -------------------------------------------------------------------------
138
139
140JavaScriptFrameIterator::JavaScriptFrameIterator(
141    Isolate* isolate, StackFrame::Id id)
142    : iterator_(isolate) {
143  while (!done()) {
144    Advance();
145    if (frame()->id() == id) return;
146  }
147}
148
149
150void JavaScriptFrameIterator::Advance() {
151  do {
152    iterator_.Advance();
153  } while (!iterator_.done() && !iterator_.frame()->is_java_script());
154}
155
156
157void JavaScriptFrameIterator::AdvanceToArgumentsFrame() {
158  if (!frame()->has_adapted_arguments()) return;
159  iterator_.Advance();
160  DCHECK(iterator_.frame()->is_arguments_adaptor());
161}
162
163
164// -------------------------------------------------------------------------
165
166
167StackTraceFrameIterator::StackTraceFrameIterator(Isolate* isolate)
168    : JavaScriptFrameIterator(isolate) {
169  if (!done() && !IsValidFrame()) Advance();
170}
171
172
173void StackTraceFrameIterator::Advance() {
174  while (true) {
175    JavaScriptFrameIterator::Advance();
176    if (done()) return;
177    if (IsValidFrame()) return;
178  }
179}
180
181
182bool StackTraceFrameIterator::IsValidFrame() {
183    if (!frame()->function()->IsJSFunction()) return false;
184    Object* script = frame()->function()->shared()->script();
185    // Don't show functions from native scripts to user.
186    return (script->IsScript() &&
187            Script::TYPE_NATIVE != Script::cast(script)->type()->value());
188}
189
190
191// -------------------------------------------------------------------------
192
193
194SafeStackFrameIterator::SafeStackFrameIterator(
195    Isolate* isolate,
196    Address fp, Address sp, Address js_entry_sp)
197    : StackFrameIteratorBase(isolate, false),
198      low_bound_(sp),
199      high_bound_(js_entry_sp),
200      top_frame_type_(StackFrame::NONE),
201      external_callback_scope_(isolate->external_callback_scope()) {
202  StackFrame::State state;
203  StackFrame::Type type;
204  ThreadLocalTop* top = isolate->thread_local_top();
205  if (IsValidTop(top)) {
206    type = ExitFrame::GetStateForFramePointer(Isolate::c_entry_fp(top), &state);
207    top_frame_type_ = type;
208  } else if (IsValidStackAddress(fp)) {
209    DCHECK(fp != NULL);
210    state.fp = fp;
211    state.sp = sp;
212    state.pc_address = StackFrame::ResolveReturnAddressLocation(
213        reinterpret_cast<Address*>(StandardFrame::ComputePCAddress(fp)));
214    // StackFrame::ComputeType will read both kContextOffset and kMarkerOffset,
215    // we check only that kMarkerOffset is within the stack bounds and do
216    // compile time check that kContextOffset slot is pushed on the stack before
217    // kMarkerOffset.
218    STATIC_ASSERT(StandardFrameConstants::kMarkerOffset <
219                  StandardFrameConstants::kContextOffset);
220    Address frame_marker = fp + StandardFrameConstants::kMarkerOffset;
221    if (IsValidStackAddress(frame_marker)) {
222      type = StackFrame::ComputeType(this, &state);
223      top_frame_type_ = type;
224    } else {
225      // Mark the frame as JAVA_SCRIPT if we cannot determine its type.
226      // The frame anyways will be skipped.
227      type = StackFrame::JAVA_SCRIPT;
228      // Top frame is incomplete so we cannot reliably determine its type.
229      top_frame_type_ = StackFrame::NONE;
230    }
231  } else {
232    return;
233  }
234  if (SingletonFor(type) == NULL) return;
235  frame_ = SingletonFor(type, &state);
236  if (frame_ == NULL) return;
237
238  Advance();
239
240  if (frame_ != NULL && !frame_->is_exit() &&
241      external_callback_scope_ != NULL &&
242      external_callback_scope_->scope_address() < frame_->fp()) {
243    // Skip top ExternalCallbackScope if we already advanced to a JS frame
244    // under it. Sampler will anyways take this top external callback.
245    external_callback_scope_ = external_callback_scope_->previous();
246  }
247}
248
249
250bool SafeStackFrameIterator::IsValidTop(ThreadLocalTop* top) const {
251  Address c_entry_fp = Isolate::c_entry_fp(top);
252  if (!IsValidExitFrame(c_entry_fp)) return false;
253  // There should be at least one JS_ENTRY stack handler.
254  Address handler = Isolate::handler(top);
255  if (handler == NULL) return false;
256  // Check that there are no js frames on top of the native frames.
257  return c_entry_fp < handler;
258}
259
260
261void SafeStackFrameIterator::AdvanceOneFrame() {
262  DCHECK(!done());
263  StackFrame* last_frame = frame_;
264  Address last_sp = last_frame->sp(), last_fp = last_frame->fp();
265  // Before advancing to the next stack frame, perform pointer validity tests.
266  if (!IsValidFrame(last_frame) || !IsValidCaller(last_frame)) {
267    frame_ = NULL;
268    return;
269  }
270
271  // Advance to the previous frame.
272  StackFrame::State state;
273  StackFrame::Type type = frame_->GetCallerState(&state);
274  frame_ = SingletonFor(type, &state);
275  if (frame_ == NULL) return;
276
277  // Check that we have actually moved to the previous frame in the stack.
278  if (frame_->sp() < last_sp || frame_->fp() < last_fp) {
279    frame_ = NULL;
280  }
281}
282
283
284bool SafeStackFrameIterator::IsValidFrame(StackFrame* frame) const {
285  return IsValidStackAddress(frame->sp()) && IsValidStackAddress(frame->fp());
286}
287
288
289bool SafeStackFrameIterator::IsValidCaller(StackFrame* frame) {
290  StackFrame::State state;
291  if (frame->is_entry() || frame->is_entry_construct()) {
292    // See EntryFrame::GetCallerState. It computes the caller FP address
293    // and calls ExitFrame::GetStateForFramePointer on it. We need to be
294    // sure that caller FP address is valid.
295    Address caller_fp = Memory::Address_at(
296        frame->fp() + EntryFrameConstants::kCallerFPOffset);
297    if (!IsValidExitFrame(caller_fp)) return false;
298  } else if (frame->is_arguments_adaptor()) {
299    // See ArgumentsAdaptorFrame::GetCallerStackPointer. It assumes that
300    // the number of arguments is stored on stack as Smi. We need to check
301    // that it really an Smi.
302    Object* number_of_args = reinterpret_cast<ArgumentsAdaptorFrame*>(frame)->
303        GetExpression(0);
304    if (!number_of_args->IsSmi()) {
305      return false;
306    }
307  }
308  frame->ComputeCallerState(&state);
309  return IsValidStackAddress(state.sp) && IsValidStackAddress(state.fp) &&
310      SingletonFor(frame->GetCallerState(&state)) != NULL;
311}
312
313
314bool SafeStackFrameIterator::IsValidExitFrame(Address fp) const {
315  if (!IsValidStackAddress(fp)) return false;
316  Address sp = ExitFrame::ComputeStackPointer(fp);
317  if (!IsValidStackAddress(sp)) return false;
318  StackFrame::State state;
319  ExitFrame::FillState(fp, sp, &state);
320  if (!IsValidStackAddress(reinterpret_cast<Address>(state.pc_address))) {
321    return false;
322  }
323  return *state.pc_address != NULL;
324}
325
326
327void SafeStackFrameIterator::Advance() {
328  while (true) {
329    AdvanceOneFrame();
330    if (done()) return;
331    if (frame_->is_java_script()) return;
332    if (frame_->is_exit() && external_callback_scope_) {
333      // Some of the EXIT frames may have ExternalCallbackScope allocated on
334      // top of them. In that case the scope corresponds to the first EXIT
335      // frame beneath it. There may be other EXIT frames on top of the
336      // ExternalCallbackScope, just skip them as we cannot collect any useful
337      // information about them.
338      if (external_callback_scope_->scope_address() < frame_->fp()) {
339        Address* callback_address =
340            external_callback_scope_->callback_address();
341        if (*callback_address != NULL) {
342          frame_->state_.pc_address = callback_address;
343        }
344        external_callback_scope_ = external_callback_scope_->previous();
345        DCHECK(external_callback_scope_ == NULL ||
346               external_callback_scope_->scope_address() > frame_->fp());
347        return;
348      }
349    }
350  }
351}
352
353
354// -------------------------------------------------------------------------
355
356
357Code* StackFrame::GetSafepointData(Isolate* isolate,
358                                   Address inner_pointer,
359                                   SafepointEntry* safepoint_entry,
360                                   unsigned* stack_slots) {
361  InnerPointerToCodeCache::InnerPointerToCodeCacheEntry* entry =
362      isolate->inner_pointer_to_code_cache()->GetCacheEntry(inner_pointer);
363  if (!entry->safepoint_entry.is_valid()) {
364    entry->safepoint_entry = entry->code->GetSafepointEntry(inner_pointer);
365    DCHECK(entry->safepoint_entry.is_valid());
366  } else {
367    DCHECK(entry->safepoint_entry.Equals(
368        entry->code->GetSafepointEntry(inner_pointer)));
369  }
370
371  // Fill in the results and return the code.
372  Code* code = entry->code;
373  *safepoint_entry = entry->safepoint_entry;
374  *stack_slots = code->stack_slots();
375  return code;
376}
377
378
379bool StackFrame::HasHandler() const {
380  StackHandlerIterator it(this, top_handler());
381  return !it.done();
382}
383
384
385#ifdef DEBUG
386static bool GcSafeCodeContains(HeapObject* object, Address addr);
387#endif
388
389
390void StackFrame::IteratePc(ObjectVisitor* v,
391                           Address* pc_address,
392                           Code* holder) {
393  Address pc = *pc_address;
394  DCHECK(GcSafeCodeContains(holder, pc));
395  unsigned pc_offset = static_cast<unsigned>(pc - holder->instruction_start());
396  Object* code = holder;
397  v->VisitPointer(&code);
398  if (code != holder) {
399    holder = reinterpret_cast<Code*>(code);
400    pc = holder->instruction_start() + pc_offset;
401    *pc_address = pc;
402  }
403}
404
405
406void StackFrame::SetReturnAddressLocationResolver(
407    ReturnAddressLocationResolver resolver) {
408  DCHECK(return_address_location_resolver_ == NULL);
409  return_address_location_resolver_ = resolver;
410}
411
412
413StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
414                                         State* state) {
415  DCHECK(state->fp != NULL);
416  if (StandardFrame::IsArgumentsAdaptorFrame(state->fp)) {
417    return ARGUMENTS_ADAPTOR;
418  }
419  // The marker and function offsets overlap. If the marker isn't a
420  // smi then the frame is a JavaScript frame -- and the marker is
421  // really the function.
422  const int offset = StandardFrameConstants::kMarkerOffset;
423  Object* marker = Memory::Object_at(state->fp + offset);
424  if (!marker->IsSmi()) {
425    // If we're using a "safe" stack iterator, we treat optimized
426    // frames as normal JavaScript frames to avoid having to look
427    // into the heap to determine the state. This is safe as long
428    // as nobody tries to GC...
429    if (!iterator->can_access_heap_objects_) return JAVA_SCRIPT;
430    Code::Kind kind = GetContainingCode(iterator->isolate(),
431                                        *(state->pc_address))->kind();
432    DCHECK(kind == Code::FUNCTION || kind == Code::OPTIMIZED_FUNCTION);
433    return (kind == Code::OPTIMIZED_FUNCTION) ? OPTIMIZED : JAVA_SCRIPT;
434  }
435  return static_cast<StackFrame::Type>(Smi::cast(marker)->value());
436}
437
438
439#ifdef DEBUG
440bool StackFrame::can_access_heap_objects() const {
441  return iterator_->can_access_heap_objects_;
442}
443#endif
444
445
446StackFrame::Type StackFrame::GetCallerState(State* state) const {
447  ComputeCallerState(state);
448  return ComputeType(iterator_, state);
449}
450
451
452Address StackFrame::UnpaddedFP() const {
453#if V8_TARGET_ARCH_IA32 || V8_TARGET_ARCH_X87
454  if (!is_optimized()) return fp();
455  int32_t alignment_state = Memory::int32_at(
456    fp() + JavaScriptFrameConstants::kDynamicAlignmentStateOffset);
457
458  return (alignment_state == kAlignmentPaddingPushed) ?
459    (fp() + kPointerSize) : fp();
460#else
461  return fp();
462#endif
463}
464
465
466Code* EntryFrame::unchecked_code() const {
467  return isolate()->heap()->js_entry_code();
468}
469
470
471void EntryFrame::ComputeCallerState(State* state) const {
472  GetCallerState(state);
473}
474
475
476void EntryFrame::SetCallerFp(Address caller_fp) {
477  const int offset = EntryFrameConstants::kCallerFPOffset;
478  Memory::Address_at(this->fp() + offset) = caller_fp;
479}
480
481
482StackFrame::Type EntryFrame::GetCallerState(State* state) const {
483  const int offset = EntryFrameConstants::kCallerFPOffset;
484  Address fp = Memory::Address_at(this->fp() + offset);
485  return ExitFrame::GetStateForFramePointer(fp, state);
486}
487
488
489Code* EntryConstructFrame::unchecked_code() const {
490  return isolate()->heap()->js_construct_entry_code();
491}
492
493
494Object*& ExitFrame::code_slot() const {
495  const int offset = ExitFrameConstants::kCodeOffset;
496  return Memory::Object_at(fp() + offset);
497}
498
499
500Code* ExitFrame::unchecked_code() const {
501  return reinterpret_cast<Code*>(code_slot());
502}
503
504
505void ExitFrame::ComputeCallerState(State* state) const {
506  // Set up the caller state.
507  state->sp = caller_sp();
508  state->fp = Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset);
509  state->pc_address = ResolveReturnAddressLocation(
510      reinterpret_cast<Address*>(fp() + ExitFrameConstants::kCallerPCOffset));
511  if (FLAG_enable_ool_constant_pool) {
512    state->constant_pool_address = reinterpret_cast<Address*>(
513        fp() + ExitFrameConstants::kConstantPoolOffset);
514  }
515}
516
517
518void ExitFrame::SetCallerFp(Address caller_fp) {
519  Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset) = caller_fp;
520}
521
522
523void ExitFrame::Iterate(ObjectVisitor* v) const {
524  // The arguments are traversed as part of the expression stack of
525  // the calling frame.
526  IteratePc(v, pc_address(), LookupCode());
527  v->VisitPointer(&code_slot());
528  if (FLAG_enable_ool_constant_pool) {
529    v->VisitPointer(&constant_pool_slot());
530  }
531}
532
533
534Address ExitFrame::GetCallerStackPointer() const {
535  return fp() + ExitFrameConstants::kCallerSPDisplacement;
536}
537
538
539StackFrame::Type ExitFrame::GetStateForFramePointer(Address fp, State* state) {
540  if (fp == 0) return NONE;
541  Address sp = ComputeStackPointer(fp);
542  FillState(fp, sp, state);
543  DCHECK(*state->pc_address != NULL);
544  return EXIT;
545}
546
547
548Address ExitFrame::ComputeStackPointer(Address fp) {
549  return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
550}
551
552
553void ExitFrame::FillState(Address fp, Address sp, State* state) {
554  state->sp = sp;
555  state->fp = fp;
556  state->pc_address = ResolveReturnAddressLocation(
557      reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
558  state->constant_pool_address =
559      reinterpret_cast<Address*>(fp + ExitFrameConstants::kConstantPoolOffset);
560}
561
562
563Address StandardFrame::GetExpressionAddress(int n) const {
564  const int offset = StandardFrameConstants::kExpressionsOffset;
565  return fp() + offset - n * kPointerSize;
566}
567
568
569Object* StandardFrame::GetExpression(Address fp, int index) {
570  return Memory::Object_at(GetExpressionAddress(fp, index));
571}
572
573
574Address StandardFrame::GetExpressionAddress(Address fp, int n) {
575  const int offset = StandardFrameConstants::kExpressionsOffset;
576  return fp + offset - n * kPointerSize;
577}
578
579
580int StandardFrame::ComputeExpressionsCount() const {
581  const int offset =
582      StandardFrameConstants::kExpressionsOffset + kPointerSize;
583  Address base = fp() + offset;
584  Address limit = sp();
585  DCHECK(base >= limit);  // stack grows downwards
586  // Include register-allocated locals in number of expressions.
587  return static_cast<int>((base - limit) / kPointerSize);
588}
589
590
591void StandardFrame::ComputeCallerState(State* state) const {
592  state->sp = caller_sp();
593  state->fp = caller_fp();
594  state->pc_address = ResolveReturnAddressLocation(
595      reinterpret_cast<Address*>(ComputePCAddress(fp())));
596  state->constant_pool_address =
597      reinterpret_cast<Address*>(ComputeConstantPoolAddress(fp()));
598}
599
600
601void StandardFrame::SetCallerFp(Address caller_fp) {
602  Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset) =
603      caller_fp;
604}
605
606
607bool StandardFrame::IsExpressionInsideHandler(int n) const {
608  Address address = GetExpressionAddress(n);
609  for (StackHandlerIterator it(this, top_handler()); !it.done(); it.Advance()) {
610    if (it.handler()->includes(address)) return true;
611  }
612  return false;
613}
614
615
616void StandardFrame::IterateCompiledFrame(ObjectVisitor* v) const {
617  // Make sure that we're not doing "safe" stack frame iteration. We cannot
618  // possibly find pointers in optimized frames in that state.
619  DCHECK(can_access_heap_objects());
620
621  // Compute the safepoint information.
622  unsigned stack_slots = 0;
623  SafepointEntry safepoint_entry;
624  Code* code = StackFrame::GetSafepointData(
625      isolate(), pc(), &safepoint_entry, &stack_slots);
626  unsigned slot_space = stack_slots * kPointerSize;
627
628  // Visit the outgoing parameters.
629  Object** parameters_base = &Memory::Object_at(sp());
630  Object** parameters_limit = &Memory::Object_at(
631      fp() + JavaScriptFrameConstants::kFunctionOffset - slot_space);
632
633  // Visit the parameters that may be on top of the saved registers.
634  if (safepoint_entry.argument_count() > 0) {
635    v->VisitPointers(parameters_base,
636                     parameters_base + safepoint_entry.argument_count());
637    parameters_base += safepoint_entry.argument_count();
638  }
639
640  // Skip saved double registers.
641  if (safepoint_entry.has_doubles()) {
642    // Number of doubles not known at snapshot time.
643    DCHECK(!isolate()->serializer_enabled());
644    parameters_base += DoubleRegister::NumAllocatableRegisters() *
645        kDoubleSize / kPointerSize;
646  }
647
648  // Visit the registers that contain pointers if any.
649  if (safepoint_entry.HasRegisters()) {
650    for (int i = kNumSafepointRegisters - 1; i >=0; i--) {
651      if (safepoint_entry.HasRegisterAt(i)) {
652        int reg_stack_index = MacroAssembler::SafepointRegisterStackIndex(i);
653        v->VisitPointer(parameters_base + reg_stack_index);
654      }
655    }
656    // Skip the words containing the register values.
657    parameters_base += kNumSafepointRegisters;
658  }
659
660  // We're done dealing with the register bits.
661  uint8_t* safepoint_bits = safepoint_entry.bits();
662  safepoint_bits += kNumSafepointRegisters >> kBitsPerByteLog2;
663
664  // Visit the rest of the parameters.
665  v->VisitPointers(parameters_base, parameters_limit);
666
667  // Visit pointer spill slots and locals.
668  for (unsigned index = 0; index < stack_slots; index++) {
669    int byte_index = index >> kBitsPerByteLog2;
670    int bit_index = index & (kBitsPerByte - 1);
671    if ((safepoint_bits[byte_index] & (1U << bit_index)) != 0) {
672      v->VisitPointer(parameters_limit + index);
673    }
674  }
675
676  // Visit the return address in the callee and incoming arguments.
677  IteratePc(v, pc_address(), code);
678
679  // Visit the context in stub frame and JavaScript frame.
680  // Visit the function in JavaScript frame.
681  Object** fixed_base = &Memory::Object_at(
682      fp() + StandardFrameConstants::kMarkerOffset);
683  Object** fixed_limit = &Memory::Object_at(fp());
684  v->VisitPointers(fixed_base, fixed_limit);
685}
686
687
688void StubFrame::Iterate(ObjectVisitor* v) const {
689  IterateCompiledFrame(v);
690}
691
692
693Code* StubFrame::unchecked_code() const {
694  return static_cast<Code*>(isolate()->FindCodeObject(pc()));
695}
696
697
698Address StubFrame::GetCallerStackPointer() const {
699  return fp() + ExitFrameConstants::kCallerSPDisplacement;
700}
701
702
703int StubFrame::GetNumberOfIncomingArguments() const {
704  return 0;
705}
706
707
708void OptimizedFrame::Iterate(ObjectVisitor* v) const {
709#ifdef DEBUG
710  // Make sure that optimized frames do not contain any stack handlers.
711  StackHandlerIterator it(this, top_handler());
712  DCHECK(it.done());
713#endif
714
715  IterateCompiledFrame(v);
716}
717
718
719void JavaScriptFrame::SetParameterValue(int index, Object* value) const {
720  Memory::Object_at(GetParameterSlot(index)) = value;
721}
722
723
724bool JavaScriptFrame::IsConstructor() const {
725  Address fp = caller_fp();
726  if (has_adapted_arguments()) {
727    // Skip the arguments adaptor frame and look at the real caller.
728    fp = Memory::Address_at(fp + StandardFrameConstants::kCallerFPOffset);
729  }
730  return IsConstructFrame(fp);
731}
732
733
734int JavaScriptFrame::GetArgumentsLength() const {
735  // If there is an arguments adaptor frame get the arguments length from it.
736  if (has_adapted_arguments()) {
737    return Smi::cast(GetExpression(caller_fp(), 0))->value();
738  } else {
739    return GetNumberOfIncomingArguments();
740  }
741}
742
743
744Code* JavaScriptFrame::unchecked_code() const {
745  return function()->code();
746}
747
748
749int JavaScriptFrame::GetNumberOfIncomingArguments() const {
750  DCHECK(can_access_heap_objects() &&
751         isolate()->heap()->gc_state() == Heap::NOT_IN_GC);
752
753  return function()->shared()->formal_parameter_count();
754}
755
756
757Address JavaScriptFrame::GetCallerStackPointer() const {
758  return fp() + StandardFrameConstants::kCallerSPOffset;
759}
760
761
762void JavaScriptFrame::GetFunctions(List<JSFunction*>* functions) {
763  DCHECK(functions->length() == 0);
764  functions->Add(function());
765}
766
767
768void JavaScriptFrame::Summarize(List<FrameSummary>* functions) {
769  DCHECK(functions->length() == 0);
770  Code* code_pointer = LookupCode();
771  int offset = static_cast<int>(pc() - code_pointer->address());
772  FrameSummary summary(receiver(),
773                       function(),
774                       code_pointer,
775                       offset,
776                       IsConstructor());
777  functions->Add(summary);
778}
779
780
781void JavaScriptFrame::PrintFunctionAndOffset(JSFunction* function, Code* code,
782                                             Address pc, FILE* file,
783                                             bool print_line_number) {
784  PrintF(file, "%s", function->IsOptimized() ? "*" : "~");
785  function->PrintName(file);
786  int code_offset = static_cast<int>(pc - code->instruction_start());
787  PrintF(file, "+%d", code_offset);
788  if (print_line_number) {
789    SharedFunctionInfo* shared = function->shared();
790    int source_pos = code->SourcePosition(pc);
791    Object* maybe_script = shared->script();
792    if (maybe_script->IsScript()) {
793      Script* script = Script::cast(maybe_script);
794      int line = script->GetLineNumber(source_pos) + 1;
795      Object* script_name_raw = script->name();
796      if (script_name_raw->IsString()) {
797        String* script_name = String::cast(script->name());
798        SmartArrayPointer<char> c_script_name =
799            script_name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
800        PrintF(file, " at %s:%d", c_script_name.get(), line);
801      } else {
802        PrintF(file, " at <unknown>:%d", line);
803      }
804    } else {
805      PrintF(file, " at <unknown>:<unknown>");
806    }
807  }
808}
809
810
811void JavaScriptFrame::PrintTop(Isolate* isolate, FILE* file, bool print_args,
812                               bool print_line_number) {
813  // constructor calls
814  DisallowHeapAllocation no_allocation;
815  JavaScriptFrameIterator it(isolate);
816  while (!it.done()) {
817    if (it.frame()->is_java_script()) {
818      JavaScriptFrame* frame = it.frame();
819      if (frame->IsConstructor()) PrintF(file, "new ");
820      PrintFunctionAndOffset(frame->function(), frame->unchecked_code(),
821                             frame->pc(), file, print_line_number);
822      if (print_args) {
823        // function arguments
824        // (we are intentionally only printing the actually
825        // supplied parameters, not all parameters required)
826        PrintF(file, "(this=");
827        frame->receiver()->ShortPrint(file);
828        const int length = frame->ComputeParametersCount();
829        for (int i = 0; i < length; i++) {
830          PrintF(file, ", ");
831          frame->GetParameter(i)->ShortPrint(file);
832        }
833        PrintF(file, ")");
834      }
835      break;
836    }
837    it.Advance();
838  }
839}
840
841
842void JavaScriptFrame::SaveOperandStack(FixedArray* store,
843                                       int* stack_handler_index) const {
844  int operands_count = store->length();
845  DCHECK_LE(operands_count, ComputeOperandsCount());
846
847  // Visit the stack in LIFO order, saving operands and stack handlers into the
848  // array.  The saved stack handlers store a link to the next stack handler,
849  // which will allow RestoreOperandStack to rewind the handlers.
850  StackHandlerIterator it(this, top_handler());
851  int i = operands_count - 1;
852  *stack_handler_index = -1;
853  for (; !it.done(); it.Advance()) {
854    StackHandler* handler = it.handler();
855    // Save operands pushed after the handler was pushed.
856    for (; GetOperandSlot(i) < handler->address(); i--) {
857      store->set(i, GetOperand(i));
858    }
859    DCHECK_GE(i + 1, StackHandlerConstants::kSlotCount);
860    DCHECK_EQ(handler->address(), GetOperandSlot(i));
861    int next_stack_handler_index = i + 1 - StackHandlerConstants::kSlotCount;
862    handler->Unwind(isolate(), store, next_stack_handler_index,
863                    *stack_handler_index);
864    *stack_handler_index = next_stack_handler_index;
865    i -= StackHandlerConstants::kSlotCount;
866  }
867
868  // Save any remaining operands.
869  for (; i >= 0; i--) {
870    store->set(i, GetOperand(i));
871  }
872}
873
874
875void JavaScriptFrame::RestoreOperandStack(FixedArray* store,
876                                          int stack_handler_index) {
877  int operands_count = store->length();
878  DCHECK_LE(operands_count, ComputeOperandsCount());
879  int i = 0;
880  while (i <= stack_handler_index) {
881    if (i < stack_handler_index) {
882      // An operand.
883      DCHECK_EQ(GetOperand(i), isolate()->heap()->the_hole_value());
884      Memory::Object_at(GetOperandSlot(i)) = store->get(i);
885      i++;
886    } else {
887      // A stack handler.
888      DCHECK_EQ(i, stack_handler_index);
889      // The FixedArray store grows up.  The stack grows down.  So the operand
890      // slot for i actually points to the bottom of the top word in the
891      // handler.  The base of the StackHandler* is the address of the bottom
892      // word, which will be the last slot that is in the handler.
893      int handler_slot_index = i + StackHandlerConstants::kSlotCount - 1;
894      StackHandler *handler =
895          StackHandler::FromAddress(GetOperandSlot(handler_slot_index));
896      stack_handler_index = handler->Rewind(isolate(), store, i, fp());
897      i += StackHandlerConstants::kSlotCount;
898    }
899  }
900
901  for (; i < operands_count; i++) {
902    DCHECK_EQ(GetOperand(i), isolate()->heap()->the_hole_value());
903    Memory::Object_at(GetOperandSlot(i)) = store->get(i);
904  }
905}
906
907
908void FrameSummary::Print() {
909  PrintF("receiver: ");
910  receiver_->ShortPrint();
911  PrintF("\nfunction: ");
912  function_->shared()->DebugName()->ShortPrint();
913  PrintF("\ncode: ");
914  code_->ShortPrint();
915  if (code_->kind() == Code::FUNCTION) PrintF(" NON-OPT");
916  if (code_->kind() == Code::OPTIMIZED_FUNCTION) PrintF(" OPT");
917  PrintF("\npc: %d\n", offset_);
918}
919
920
921JSFunction* OptimizedFrame::LiteralAt(FixedArray* literal_array,
922                                      int literal_id) {
923  if (literal_id == Translation::kSelfLiteralId) {
924    return function();
925  }
926
927  return JSFunction::cast(literal_array->get(literal_id));
928}
929
930
931void OptimizedFrame::Summarize(List<FrameSummary>* frames) {
932  DCHECK(frames->length() == 0);
933  DCHECK(is_optimized());
934
935  // Delegate to JS frame in absence of turbofan deoptimization.
936  // TODO(turbofan): Revisit once we support deoptimization across the board.
937  if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
938    return JavaScriptFrame::Summarize(frames);
939  }
940
941  int deopt_index = Safepoint::kNoDeoptimizationIndex;
942  DeoptimizationInputData* data = GetDeoptimizationData(&deopt_index);
943  FixedArray* literal_array = data->LiteralArray();
944
945  // BUG(3243555): Since we don't have a lazy-deopt registered at
946  // throw-statements, we can't use the translation at the call-site of
947  // throw. An entry with no deoptimization index indicates a call-site
948  // without a lazy-deopt. As a consequence we are not allowed to inline
949  // functions containing throw.
950  DCHECK(deopt_index != Safepoint::kNoDeoptimizationIndex);
951
952  TranslationIterator it(data->TranslationByteArray(),
953                         data->TranslationIndex(deopt_index)->value());
954  Translation::Opcode opcode = static_cast<Translation::Opcode>(it.Next());
955  DCHECK(opcode == Translation::BEGIN);
956  it.Next();  // Drop frame count.
957  int jsframe_count = it.Next();
958
959  // We create the summary in reverse order because the frames
960  // in the deoptimization translation are ordered bottom-to-top.
961  bool is_constructor = IsConstructor();
962  int i = jsframe_count;
963  while (i > 0) {
964    opcode = static_cast<Translation::Opcode>(it.Next());
965    if (opcode == Translation::JS_FRAME) {
966      i--;
967      BailoutId ast_id = BailoutId(it.Next());
968      JSFunction* function = LiteralAt(literal_array, it.Next());
969      it.Next();  // Skip height.
970
971      // The translation commands are ordered and the receiver is always
972      // at the first position.
973      // If we are at a call, the receiver is always in a stack slot.
974      // Otherwise we are not guaranteed to get the receiver value.
975      opcode = static_cast<Translation::Opcode>(it.Next());
976      int index = it.Next();
977
978      // Get the correct receiver in the optimized frame.
979      Object* receiver = NULL;
980      if (opcode == Translation::LITERAL) {
981        receiver = data->LiteralArray()->get(index);
982      } else if (opcode == Translation::STACK_SLOT) {
983        // Positive index means the value is spilled to the locals
984        // area. Negative means it is stored in the incoming parameter
985        // area.
986        if (index >= 0) {
987          receiver = GetExpression(index);
988        } else {
989          // Index -1 overlaps with last parameter, -n with the first parameter,
990          // (-n - 1) with the receiver with n being the number of parameters
991          // of the outermost, optimized frame.
992          int parameter_count = ComputeParametersCount();
993          int parameter_index = index + parameter_count;
994          receiver = (parameter_index == -1)
995              ? this->receiver()
996              : this->GetParameter(parameter_index);
997        }
998      } else {
999        // The receiver is not in a stack slot nor in a literal.  We give up.
1000        // TODO(3029): Materializing a captured object (or duplicated
1001        // object) is hard, we return undefined for now. This breaks the
1002        // produced stack trace, as constructor frames aren't marked as
1003        // such anymore.
1004        receiver = isolate()->heap()->undefined_value();
1005      }
1006
1007      Code* code = function->shared()->code();
1008      DeoptimizationOutputData* output_data =
1009          DeoptimizationOutputData::cast(code->deoptimization_data());
1010      unsigned entry = Deoptimizer::GetOutputInfo(output_data,
1011                                                  ast_id,
1012                                                  function->shared());
1013      unsigned pc_offset =
1014          FullCodeGenerator::PcField::decode(entry) + Code::kHeaderSize;
1015      DCHECK(pc_offset > 0);
1016
1017      FrameSummary summary(receiver, function, code, pc_offset, is_constructor);
1018      frames->Add(summary);
1019      is_constructor = false;
1020    } else if (opcode == Translation::CONSTRUCT_STUB_FRAME) {
1021      // The next encountered JS_FRAME will be marked as a constructor call.
1022      it.Skip(Translation::NumberOfOperandsFor(opcode));
1023      DCHECK(!is_constructor);
1024      is_constructor = true;
1025    } else {
1026      // Skip over operands to advance to the next opcode.
1027      it.Skip(Translation::NumberOfOperandsFor(opcode));
1028    }
1029  }
1030  DCHECK(!is_constructor);
1031}
1032
1033
1034DeoptimizationInputData* OptimizedFrame::GetDeoptimizationData(
1035    int* deopt_index) {
1036  DCHECK(is_optimized());
1037
1038  JSFunction* opt_function = function();
1039  Code* code = opt_function->code();
1040
1041  // The code object may have been replaced by lazy deoptimization. Fall
1042  // back to a slow search in this case to find the original optimized
1043  // code object.
1044  if (!code->contains(pc())) {
1045    code = isolate()->inner_pointer_to_code_cache()->
1046        GcSafeFindCodeForInnerPointer(pc());
1047  }
1048  DCHECK(code != NULL);
1049  DCHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
1050
1051  SafepointEntry safepoint_entry = code->GetSafepointEntry(pc());
1052  *deopt_index = safepoint_entry.deoptimization_index();
1053  DCHECK(*deopt_index != Safepoint::kNoDeoptimizationIndex);
1054
1055  return DeoptimizationInputData::cast(code->deoptimization_data());
1056}
1057
1058
1059int OptimizedFrame::GetInlineCount() {
1060  DCHECK(is_optimized());
1061
1062  // Delegate to JS frame in absence of turbofan deoptimization.
1063  // TODO(turbofan): Revisit once we support deoptimization across the board.
1064  if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
1065    return JavaScriptFrame::GetInlineCount();
1066  }
1067
1068  int deopt_index = Safepoint::kNoDeoptimizationIndex;
1069  DeoptimizationInputData* data = GetDeoptimizationData(&deopt_index);
1070
1071  TranslationIterator it(data->TranslationByteArray(),
1072                         data->TranslationIndex(deopt_index)->value());
1073  Translation::Opcode opcode = static_cast<Translation::Opcode>(it.Next());
1074  DCHECK(opcode == Translation::BEGIN);
1075  USE(opcode);
1076  it.Next();  // Drop frame count.
1077  int jsframe_count = it.Next();
1078  return jsframe_count;
1079}
1080
1081
1082void OptimizedFrame::GetFunctions(List<JSFunction*>* functions) {
1083  DCHECK(functions->length() == 0);
1084  DCHECK(is_optimized());
1085
1086  // Delegate to JS frame in absence of turbofan deoptimization.
1087  // TODO(turbofan): Revisit once we support deoptimization across the board.
1088  if (LookupCode()->is_turbofanned() && !FLAG_turbo_deoptimization) {
1089    return JavaScriptFrame::GetFunctions(functions);
1090  }
1091
1092  int deopt_index = Safepoint::kNoDeoptimizationIndex;
1093  DeoptimizationInputData* data = GetDeoptimizationData(&deopt_index);
1094  FixedArray* literal_array = data->LiteralArray();
1095
1096  TranslationIterator it(data->TranslationByteArray(),
1097                         data->TranslationIndex(deopt_index)->value());
1098  Translation::Opcode opcode = static_cast<Translation::Opcode>(it.Next());
1099  DCHECK(opcode == Translation::BEGIN);
1100  it.Next();  // Drop frame count.
1101  int jsframe_count = it.Next();
1102
1103  // We insert the frames in reverse order because the frames
1104  // in the deoptimization translation are ordered bottom-to-top.
1105  while (jsframe_count > 0) {
1106    opcode = static_cast<Translation::Opcode>(it.Next());
1107    if (opcode == Translation::JS_FRAME) {
1108      jsframe_count--;
1109      it.Next();  // Skip ast id.
1110      JSFunction* function = LiteralAt(literal_array, it.Next());
1111      it.Next();  // Skip height.
1112      functions->Add(function);
1113    } else {
1114      // Skip over operands to advance to the next opcode.
1115      it.Skip(Translation::NumberOfOperandsFor(opcode));
1116    }
1117  }
1118}
1119
1120
1121int ArgumentsAdaptorFrame::GetNumberOfIncomingArguments() const {
1122  return Smi::cast(GetExpression(0))->value();
1123}
1124
1125
1126Address ArgumentsAdaptorFrame::GetCallerStackPointer() const {
1127  return fp() + StandardFrameConstants::kCallerSPOffset;
1128}
1129
1130
1131Address InternalFrame::GetCallerStackPointer() const {
1132  // Internal frames have no arguments. The stack pointer of the
1133  // caller is at a fixed offset from the frame pointer.
1134  return fp() + StandardFrameConstants::kCallerSPOffset;
1135}
1136
1137
1138Code* ArgumentsAdaptorFrame::unchecked_code() const {
1139  return isolate()->builtins()->builtin(
1140      Builtins::kArgumentsAdaptorTrampoline);
1141}
1142
1143
1144Code* InternalFrame::unchecked_code() const {
1145  const int offset = InternalFrameConstants::kCodeOffset;
1146  Object* code = Memory::Object_at(fp() + offset);
1147  DCHECK(code != NULL);
1148  return reinterpret_cast<Code*>(code);
1149}
1150
1151
1152void StackFrame::PrintIndex(StringStream* accumulator,
1153                            PrintMode mode,
1154                            int index) {
1155  accumulator->Add((mode == OVERVIEW) ? "%5d: " : "[%d]: ", index);
1156}
1157
1158
1159void JavaScriptFrame::Print(StringStream* accumulator,
1160                            PrintMode mode,
1161                            int index) const {
1162  DisallowHeapAllocation no_gc;
1163  Object* receiver = this->receiver();
1164  JSFunction* function = this->function();
1165
1166  accumulator->PrintSecurityTokenIfChanged(function);
1167  PrintIndex(accumulator, mode, index);
1168  Code* code = NULL;
1169  if (IsConstructor()) accumulator->Add("new ");
1170  accumulator->PrintFunction(function, receiver, &code);
1171
1172  // Get scope information for nicer output, if possible. If code is NULL, or
1173  // doesn't contain scope info, scope_info will return 0 for the number of
1174  // parameters, stack local variables, context local variables, stack slots,
1175  // or context slots.
1176  SharedFunctionInfo* shared = function->shared();
1177  ScopeInfo* scope_info = shared->scope_info();
1178  Object* script_obj = shared->script();
1179  if (script_obj->IsScript()) {
1180    Script* script = Script::cast(script_obj);
1181    accumulator->Add(" [");
1182    accumulator->PrintName(script->name());
1183
1184    Address pc = this->pc();
1185    if (code != NULL && code->kind() == Code::FUNCTION &&
1186        pc >= code->instruction_start() && pc < code->instruction_end()) {
1187      int source_pos = code->SourcePosition(pc);
1188      int line = script->GetLineNumber(source_pos) + 1;
1189      accumulator->Add(":%d", line);
1190    } else {
1191      int function_start_pos = shared->start_position();
1192      int line = script->GetLineNumber(function_start_pos) + 1;
1193      accumulator->Add(":~%d", line);
1194    }
1195
1196    accumulator->Add("] ");
1197  }
1198
1199  accumulator->Add("(this=%o", receiver);
1200
1201  // Print the parameters.
1202  int parameters_count = ComputeParametersCount();
1203  for (int i = 0; i < parameters_count; i++) {
1204    accumulator->Add(",");
1205    // If we have a name for the parameter we print it. Nameless
1206    // parameters are either because we have more actual parameters
1207    // than formal parameters or because we have no scope information.
1208    if (i < scope_info->ParameterCount()) {
1209      accumulator->PrintName(scope_info->ParameterName(i));
1210      accumulator->Add("=");
1211    }
1212    accumulator->Add("%o", GetParameter(i));
1213  }
1214
1215  accumulator->Add(")");
1216  if (mode == OVERVIEW) {
1217    accumulator->Add("\n");
1218    return;
1219  }
1220  if (is_optimized()) {
1221    accumulator->Add(" {\n// optimized frame\n}\n");
1222    return;
1223  }
1224  accumulator->Add(" {\n");
1225
1226  // Compute the number of locals and expression stack elements.
1227  int stack_locals_count = scope_info->StackLocalCount();
1228  int heap_locals_count = scope_info->ContextLocalCount();
1229  int expressions_count = ComputeExpressionsCount();
1230
1231  // Print stack-allocated local variables.
1232  if (stack_locals_count > 0) {
1233    accumulator->Add("  // stack-allocated locals\n");
1234  }
1235  for (int i = 0; i < stack_locals_count; i++) {
1236    accumulator->Add("  var ");
1237    accumulator->PrintName(scope_info->StackLocalName(i));
1238    accumulator->Add(" = ");
1239    if (i < expressions_count) {
1240      accumulator->Add("%o", GetExpression(i));
1241    } else {
1242      accumulator->Add("// no expression found - inconsistent frame?");
1243    }
1244    accumulator->Add("\n");
1245  }
1246
1247  // Try to get hold of the context of this frame.
1248  Context* context = NULL;
1249  if (this->context() != NULL && this->context()->IsContext()) {
1250    context = Context::cast(this->context());
1251  }
1252  while (context->IsWithContext()) {
1253    context = context->previous();
1254    DCHECK(context != NULL);
1255  }
1256
1257  // Print heap-allocated local variables.
1258  if (heap_locals_count > 0) {
1259    accumulator->Add("  // heap-allocated locals\n");
1260  }
1261  for (int i = 0; i < heap_locals_count; i++) {
1262    accumulator->Add("  var ");
1263    accumulator->PrintName(scope_info->ContextLocalName(i));
1264    accumulator->Add(" = ");
1265    if (context != NULL) {
1266      int index = Context::MIN_CONTEXT_SLOTS + i;
1267      if (index < context->length()) {
1268        accumulator->Add("%o", context->get(index));
1269      } else {
1270        accumulator->Add(
1271            "// warning: missing context slot - inconsistent frame?");
1272      }
1273    } else {
1274      accumulator->Add("// warning: no context found - inconsistent frame?");
1275    }
1276    accumulator->Add("\n");
1277  }
1278
1279  // Print the expression stack.
1280  int expressions_start = stack_locals_count;
1281  if (expressions_start < expressions_count) {
1282    accumulator->Add("  // expression stack (top to bottom)\n");
1283  }
1284  for (int i = expressions_count - 1; i >= expressions_start; i--) {
1285    if (IsExpressionInsideHandler(i)) continue;
1286    accumulator->Add("  [%02d] : %o\n", i, GetExpression(i));
1287  }
1288
1289  // Print details about the function.
1290  if (FLAG_max_stack_trace_source_length != 0 && code != NULL) {
1291    OStringStream os;
1292    SharedFunctionInfo* shared = function->shared();
1293    os << "--------- s o u r c e   c o d e ---------\n"
1294       << SourceCodeOf(shared, FLAG_max_stack_trace_source_length)
1295       << "\n-----------------------------------------\n";
1296    accumulator->Add(os.c_str());
1297  }
1298
1299  accumulator->Add("}\n\n");
1300}
1301
1302
1303void ArgumentsAdaptorFrame::Print(StringStream* accumulator,
1304                                  PrintMode mode,
1305                                  int index) const {
1306  int actual = ComputeParametersCount();
1307  int expected = -1;
1308  JSFunction* function = this->function();
1309  expected = function->shared()->formal_parameter_count();
1310
1311  PrintIndex(accumulator, mode, index);
1312  accumulator->Add("arguments adaptor frame: %d->%d", actual, expected);
1313  if (mode == OVERVIEW) {
1314    accumulator->Add("\n");
1315    return;
1316  }
1317  accumulator->Add(" {\n");
1318
1319  // Print actual arguments.
1320  if (actual > 0) accumulator->Add("  // actual arguments\n");
1321  for (int i = 0; i < actual; i++) {
1322    accumulator->Add("  [%02d] : %o", i, GetParameter(i));
1323    if (expected != -1 && i >= expected) {
1324      accumulator->Add("  // not passed to callee");
1325    }
1326    accumulator->Add("\n");
1327  }
1328
1329  accumulator->Add("}\n\n");
1330}
1331
1332
1333void EntryFrame::Iterate(ObjectVisitor* v) const {
1334  StackHandlerIterator it(this, top_handler());
1335  DCHECK(!it.done());
1336  StackHandler* handler = it.handler();
1337  DCHECK(handler->is_js_entry());
1338  handler->Iterate(v, LookupCode());
1339#ifdef DEBUG
1340  // Make sure that the entry frame does not contain more than one
1341  // stack handler.
1342  it.Advance();
1343  DCHECK(it.done());
1344#endif
1345  IteratePc(v, pc_address(), LookupCode());
1346}
1347
1348
1349void StandardFrame::IterateExpressions(ObjectVisitor* v) const {
1350  const int offset = StandardFrameConstants::kLastObjectOffset;
1351  Object** base = &Memory::Object_at(sp());
1352  Object** limit = &Memory::Object_at(fp() + offset) + 1;
1353  for (StackHandlerIterator it(this, top_handler()); !it.done(); it.Advance()) {
1354    StackHandler* handler = it.handler();
1355    // Traverse pointers down to - but not including - the next
1356    // handler in the handler chain. Update the base to skip the
1357    // handler and allow the handler to traverse its own pointers.
1358    const Address address = handler->address();
1359    v->VisitPointers(base, reinterpret_cast<Object**>(address));
1360    base = reinterpret_cast<Object**>(address + StackHandlerConstants::kSize);
1361    // Traverse the pointers in the handler itself.
1362    handler->Iterate(v, LookupCode());
1363  }
1364  v->VisitPointers(base, limit);
1365}
1366
1367
1368void JavaScriptFrame::Iterate(ObjectVisitor* v) const {
1369  IterateExpressions(v);
1370  IteratePc(v, pc_address(), LookupCode());
1371}
1372
1373
1374void InternalFrame::Iterate(ObjectVisitor* v) const {
1375  // Internal frames only have object pointers on the expression stack
1376  // as they never have any arguments.
1377  IterateExpressions(v);
1378  IteratePc(v, pc_address(), LookupCode());
1379}
1380
1381
1382void StubFailureTrampolineFrame::Iterate(ObjectVisitor* v) const {
1383  Object** base = &Memory::Object_at(sp());
1384  Object** limit = &Memory::Object_at(fp() +
1385                                      kFirstRegisterParameterFrameOffset);
1386  v->VisitPointers(base, limit);
1387  base = &Memory::Object_at(fp() + StandardFrameConstants::kMarkerOffset);
1388  const int offset = StandardFrameConstants::kLastObjectOffset;
1389  limit = &Memory::Object_at(fp() + offset) + 1;
1390  v->VisitPointers(base, limit);
1391  IteratePc(v, pc_address(), LookupCode());
1392}
1393
1394
1395Address StubFailureTrampolineFrame::GetCallerStackPointer() const {
1396  return fp() + StandardFrameConstants::kCallerSPOffset;
1397}
1398
1399
1400Code* StubFailureTrampolineFrame::unchecked_code() const {
1401  Code* trampoline;
1402  StubFailureTrampolineStub(isolate(), NOT_JS_FUNCTION_STUB_MODE).
1403      FindCodeInCache(&trampoline);
1404  if (trampoline->contains(pc())) {
1405    return trampoline;
1406  }
1407
1408  StubFailureTrampolineStub(isolate(), JS_FUNCTION_STUB_MODE).
1409      FindCodeInCache(&trampoline);
1410  if (trampoline->contains(pc())) {
1411    return trampoline;
1412  }
1413
1414  UNREACHABLE();
1415  return NULL;
1416}
1417
1418
1419// -------------------------------------------------------------------------
1420
1421
1422JavaScriptFrame* StackFrameLocator::FindJavaScriptFrame(int n) {
1423  DCHECK(n >= 0);
1424  for (int i = 0; i <= n; i++) {
1425    while (!iterator_.frame()->is_java_script()) iterator_.Advance();
1426    if (i == n) return JavaScriptFrame::cast(iterator_.frame());
1427    iterator_.Advance();
1428  }
1429  UNREACHABLE();
1430  return NULL;
1431}
1432
1433
1434// -------------------------------------------------------------------------
1435
1436
1437static Map* GcSafeMapOfCodeSpaceObject(HeapObject* object) {
1438  MapWord map_word = object->map_word();
1439  return map_word.IsForwardingAddress() ?
1440      map_word.ToForwardingAddress()->map() : map_word.ToMap();
1441}
1442
1443
1444static int GcSafeSizeOfCodeSpaceObject(HeapObject* object) {
1445  return object->SizeFromMap(GcSafeMapOfCodeSpaceObject(object));
1446}
1447
1448
1449#ifdef DEBUG
1450static bool GcSafeCodeContains(HeapObject* code, Address addr) {
1451  Map* map = GcSafeMapOfCodeSpaceObject(code);
1452  DCHECK(map == code->GetHeap()->code_map());
1453  Address start = code->address();
1454  Address end = code->address() + code->SizeFromMap(map);
1455  return start <= addr && addr < end;
1456}
1457#endif
1458
1459
1460Code* InnerPointerToCodeCache::GcSafeCastToCode(HeapObject* object,
1461                                                Address inner_pointer) {
1462  Code* code = reinterpret_cast<Code*>(object);
1463  DCHECK(code != NULL && GcSafeCodeContains(code, inner_pointer));
1464  return code;
1465}
1466
1467
1468Code* InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(
1469    Address inner_pointer) {
1470  Heap* heap = isolate_->heap();
1471  // Check if the inner pointer points into a large object chunk.
1472  LargePage* large_page = heap->lo_space()->FindPage(inner_pointer);
1473  if (large_page != NULL) {
1474    return GcSafeCastToCode(large_page->GetObject(), inner_pointer);
1475  }
1476
1477  // Iterate through the page until we reach the end or find an object starting
1478  // after the inner pointer.
1479  Page* page = Page::FromAddress(inner_pointer);
1480
1481  Address addr = page->skip_list()->StartFor(inner_pointer);
1482
1483  Address top = heap->code_space()->top();
1484  Address limit = heap->code_space()->limit();
1485
1486  while (true) {
1487    if (addr == top && addr != limit) {
1488      addr = limit;
1489      continue;
1490    }
1491
1492    HeapObject* obj = HeapObject::FromAddress(addr);
1493    int obj_size = GcSafeSizeOfCodeSpaceObject(obj);
1494    Address next_addr = addr + obj_size;
1495    if (next_addr > inner_pointer) return GcSafeCastToCode(obj, inner_pointer);
1496    addr = next_addr;
1497  }
1498}
1499
1500
1501InnerPointerToCodeCache::InnerPointerToCodeCacheEntry*
1502    InnerPointerToCodeCache::GetCacheEntry(Address inner_pointer) {
1503  isolate_->counters()->pc_to_code()->Increment();
1504  DCHECK(base::bits::IsPowerOfTwo32(kInnerPointerToCodeCacheSize));
1505  uint32_t hash = ComputeIntegerHash(
1506      static_cast<uint32_t>(reinterpret_cast<uintptr_t>(inner_pointer)),
1507      v8::internal::kZeroHashSeed);
1508  uint32_t index = hash & (kInnerPointerToCodeCacheSize - 1);
1509  InnerPointerToCodeCacheEntry* entry = cache(index);
1510  if (entry->inner_pointer == inner_pointer) {
1511    isolate_->counters()->pc_to_code_cached()->Increment();
1512    DCHECK(entry->code == GcSafeFindCodeForInnerPointer(inner_pointer));
1513  } else {
1514    // Because this code may be interrupted by a profiling signal that
1515    // also queries the cache, we cannot update inner_pointer before the code
1516    // has been set. Otherwise, we risk trying to use a cache entry before
1517    // the code has been computed.
1518    entry->code = GcSafeFindCodeForInnerPointer(inner_pointer);
1519    entry->safepoint_entry.Reset();
1520    entry->inner_pointer = inner_pointer;
1521  }
1522  return entry;
1523}
1524
1525
1526// -------------------------------------------------------------------------
1527
1528
1529void StackHandler::Unwind(Isolate* isolate,
1530                          FixedArray* array,
1531                          int offset,
1532                          int previous_handler_offset) const {
1533  STATIC_ASSERT(StackHandlerConstants::kSlotCount >= 5);
1534  DCHECK_LE(0, offset);
1535  DCHECK_GE(array->length(), offset + StackHandlerConstants::kSlotCount);
1536  // Unwinding a stack handler into an array chains it in the opposite
1537  // direction, re-using the "next" slot as a "previous" link, so that stack
1538  // handlers can be later re-wound in the correct order.  Decode the "state"
1539  // slot into "index" and "kind" and store them separately, using the fp slot.
1540  array->set(offset, Smi::FromInt(previous_handler_offset));        // next
1541  array->set(offset + 1, *code_address());                          // code
1542  array->set(offset + 2, Smi::FromInt(static_cast<int>(index())));  // state
1543  array->set(offset + 3, *context_address());                       // context
1544  array->set(offset + 4, Smi::FromInt(static_cast<int>(kind())));   // fp
1545
1546  *isolate->handler_address() = next()->address();
1547}
1548
1549
1550int StackHandler::Rewind(Isolate* isolate,
1551                         FixedArray* array,
1552                         int offset,
1553                         Address fp) {
1554  STATIC_ASSERT(StackHandlerConstants::kSlotCount >= 5);
1555  DCHECK_LE(0, offset);
1556  DCHECK_GE(array->length(), offset + StackHandlerConstants::kSlotCount);
1557  Smi* prev_handler_offset = Smi::cast(array->get(offset));
1558  Code* code = Code::cast(array->get(offset + 1));
1559  Smi* smi_index = Smi::cast(array->get(offset + 2));
1560  Object* context = array->get(offset + 3);
1561  Smi* smi_kind = Smi::cast(array->get(offset + 4));
1562
1563  unsigned state = KindField::encode(static_cast<Kind>(smi_kind->value())) |
1564      IndexField::encode(static_cast<unsigned>(smi_index->value()));
1565
1566  Memory::Address_at(address() + StackHandlerConstants::kNextOffset) =
1567      *isolate->handler_address();
1568  Memory::Object_at(address() + StackHandlerConstants::kCodeOffset) = code;
1569  Memory::uintptr_at(address() + StackHandlerConstants::kStateOffset) = state;
1570  Memory::Object_at(address() + StackHandlerConstants::kContextOffset) =
1571      context;
1572  SetFp(address() + StackHandlerConstants::kFPOffset, fp);
1573
1574  *isolate->handler_address() = address();
1575
1576  return prev_handler_offset->value();
1577}
1578
1579
1580// -------------------------------------------------------------------------
1581
1582int NumRegs(RegList reglist) { return base::bits::CountPopulation32(reglist); }
1583
1584
1585struct JSCallerSavedCodeData {
1586  int reg_code[kNumJSCallerSaved];
1587};
1588
1589JSCallerSavedCodeData caller_saved_code_data;
1590
1591void SetUpJSCallerSavedCodeData() {
1592  int i = 0;
1593  for (int r = 0; r < kNumRegs; r++)
1594    if ((kJSCallerSaved & (1 << r)) != 0)
1595      caller_saved_code_data.reg_code[i++] = r;
1596
1597  DCHECK(i == kNumJSCallerSaved);
1598}
1599
1600
1601int JSCallerSavedCode(int n) {
1602  DCHECK(0 <= n && n < kNumJSCallerSaved);
1603  return caller_saved_code_data.reg_code[n];
1604}
1605
1606
1607#define DEFINE_WRAPPER(type, field)                              \
1608class field##_Wrapper : public ZoneObject {                      \
1609 public:  /* NOLINT */                                           \
1610  field##_Wrapper(const field& original) : frame_(original) {    \
1611  }                                                              \
1612  field frame_;                                                  \
1613};
1614STACK_FRAME_TYPE_LIST(DEFINE_WRAPPER)
1615#undef DEFINE_WRAPPER
1616
1617static StackFrame* AllocateFrameCopy(StackFrame* frame, Zone* zone) {
1618#define FRAME_TYPE_CASE(type, field) \
1619  case StackFrame::type: { \
1620    field##_Wrapper* wrapper = \
1621        new(zone) field##_Wrapper(*(reinterpret_cast<field*>(frame))); \
1622    return &wrapper->frame_; \
1623  }
1624
1625  switch (frame->type()) {
1626    STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
1627    default: UNREACHABLE();
1628  }
1629#undef FRAME_TYPE_CASE
1630  return NULL;
1631}
1632
1633
1634Vector<StackFrame*> CreateStackMap(Isolate* isolate, Zone* zone) {
1635  ZoneList<StackFrame*> list(10, zone);
1636  for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
1637    StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
1638    list.Add(frame, zone);
1639  }
1640  return list.ToVector();
1641}
1642
1643
1644} }  // namespace v8::internal
1645