frames.cc 59.2 KB
Newer Older
1
// Copyright 2012 the V8 project authors. All rights reserved.
2 3
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
4

5 6 7 8
#include "src/frames.h"

#include <sstream>

9 10
#include "src/ast/ast.h"
#include "src/ast/scopeinfo.h"
11
#include "src/base/bits.h"
12 13
#include "src/deoptimizer.h"
#include "src/frames-inl.h"
14
#include "src/full-codegen/full-codegen.h"
15
#include "src/register-configuration.h"
16 17 18
#include "src/safepoint-table.h"
#include "src/string-stream.h"
#include "src/vm-state-inl.h"
19
#include "src/wasm/wasm-module.h"
20

21 22
namespace v8 {
namespace internal {
23

24 25
ReturnAddressLocationResolver
    StackFrame::return_address_location_resolver_ = NULL;
26 27


28 29 30 31 32 33 34
// Iterator that supports traversing the stack handlers of a
// particular frame. Needs to know the top of the handler chain.
class StackHandlerIterator BASE_EMBEDDED {
 public:
  StackHandlerIterator(const StackFrame* frame, StackHandler* handler)
      : limit_(frame->fp()), handler_(handler) {
    // Make sure the handler has already been unwound to this frame.
35
    DCHECK(frame->sp() <= handler->address());
36 37 38 39
  }

  StackHandler* handler() const { return handler_; }

40 41 42
  bool done() {
    return handler_ == NULL || handler_->address() > limit_;
  }
43
  void Advance() {
44
    DCHECK(!done());
45 46 47 48 49 50 51 52 53 54 55 56 57
    handler_ = handler_->next();
  }

 private:
  const Address limit_;
  StackHandler* handler_;
};


// -------------------------------------------------------------------------


#define INITIALIZE_SINGLETON(type, field) field##_(this),
58 59
StackFrameIteratorBase::StackFrameIteratorBase(Isolate* isolate,
                                               bool can_access_heap_objects)
60 61 62
    : isolate_(isolate),
      STACK_FRAME_TYPE_LIST(INITIALIZE_SINGLETON)
      frame_(NULL), handler_(NULL),
63
      can_access_heap_objects_(can_access_heap_objects) {
64
}
65 66 67 68 69 70
#undef INITIALIZE_SINGLETON


StackFrameIterator::StackFrameIterator(Isolate* isolate)
    : StackFrameIteratorBase(isolate, true) {
  Reset(isolate->thread_local_top());
71
}
72

73 74 75 76 77

StackFrameIterator::StackFrameIterator(Isolate* isolate, ThreadLocalTop* t)
    : StackFrameIteratorBase(isolate, true) {
  Reset(t);
}
78 79


80
void StackFrameIterator::Advance() {
81
  DCHECK(!done());
82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98
  // Compute the state of the calling frame before restoring
  // callee-saved registers and unwinding handlers. This allows the
  // frame code that computes the caller state to access the top
  // handler and the value of any callee-saved register if needed.
  StackFrame::State state;
  StackFrame::Type type = frame_->GetCallerState(&state);

  // Unwind handlers corresponding to the current frame.
  StackHandlerIterator it(frame_, handler_);
  while (!it.done()) it.Advance();
  handler_ = it.handler();

  // Advance to the calling frame.
  frame_ = SingletonFor(type, &state);

  // When we're done iterating over the stack frames, the handler
  // chain must have been completely unwound.
99
  DCHECK(!done() || handler_ == NULL);
100 101 102
}


103
void StackFrameIterator::Reset(ThreadLocalTop* top) {
104
  StackFrame::State state;
105 106 107
  StackFrame::Type type = ExitFrame::GetStateForFramePointer(
      Isolate::c_entry_fp(top), &state);
  handler_ = StackHandler::FromAddress(Isolate::handler(top));
108 109 110 111
  frame_ = SingletonFor(type, &state);
}


112
StackFrame* StackFrameIteratorBase::SingletonFor(StackFrame::Type type,
113
                                             StackFrame::State* state) {
114
  StackFrame* result = SingletonFor(type);
115 116
  DCHECK((!result) == (type == StackFrame::NONE));
  if (result) result->state_ = *state;
117 118 119 120
  return result;
}


121
StackFrame* StackFrameIteratorBase::SingletonFor(StackFrame::Type type) {
122
#define FRAME_TYPE_CASE(type, field) \
123 124
  case StackFrame::type:             \
    return &field##_;
125 126 127 128 129 130

  switch (type) {
    case StackFrame::NONE: return NULL;
    STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
    default: break;
  }
131
  return NULL;
132 133 134 135 136 137

#undef FRAME_TYPE_CASE
}

// -------------------------------------------------------------------------

138 139
JavaScriptFrameIterator::JavaScriptFrameIterator(Isolate* isolate,
                                                 StackFrame::Id id)
140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157
    : iterator_(isolate) {
  while (!done()) {
    Advance();
    if (frame()->id() == id) return;
  }
}


void JavaScriptFrameIterator::Advance() {
  do {
    iterator_.Advance();
  } while (!iterator_.done() && !iterator_.frame()->is_java_script());
}


void JavaScriptFrameIterator::AdvanceToArgumentsFrame() {
  if (!frame()->has_adapted_arguments()) return;
  iterator_.Advance();
158
  DCHECK(iterator_.frame()->is_arguments_adaptor());
159 160 161 162 163
}


// -------------------------------------------------------------------------

164
StackTraceFrameIterator::StackTraceFrameIterator(Isolate* isolate)
165 166
    : iterator_(isolate) {
  if (!done() && !IsValidFrame(iterator_.frame())) Advance();
167 168 169
}


170
void StackTraceFrameIterator::Advance() {
171 172 173
  do {
    iterator_.Advance();
  } while (!done() && !IsValidFrame(iterator_.frame()));
174 175
}

176 177 178 179 180
bool StackTraceFrameIterator::IsValidFrame(StackFrame* frame) const {
  if (frame->is_java_script()) {
    JavaScriptFrame* jsFrame = static_cast<JavaScriptFrame*>(frame);
    if (!jsFrame->function()->IsJSFunction()) return false;
    Object* script = jsFrame->function()->shared()->script();
181 182
    // Don't show functions from native scripts to user.
    return (script->IsScript() &&
183
            Script::TYPE_NATIVE != Script::cast(script)->type());
184 185 186
  }
  // apart from javascript, only wasm is valid
  return frame->is_wasm();
187 188
}

189

190 191 192 193
// -------------------------------------------------------------------------


SafeStackFrameIterator::SafeStackFrameIterator(
194
    Isolate* isolate,
195 196 197 198
    Address fp, Address sp, Address js_entry_sp)
    : StackFrameIteratorBase(isolate, false),
      low_bound_(sp),
      high_bound_(js_entry_sp),
199 200
      top_frame_type_(StackFrame::NONE),
      external_callback_scope_(isolate->external_callback_scope()) {
201 202 203 204 205
  StackFrame::State state;
  StackFrame::Type type;
  ThreadLocalTop* top = isolate->thread_local_top();
  if (IsValidTop(top)) {
    type = ExitFrame::GetStateForFramePointer(Isolate::c_entry_fp(top), &state);
206
    top_frame_type_ = type;
207
  } else if (IsValidStackAddress(fp)) {
208
    DCHECK(fp != NULL);
209 210
    state.fp = fp;
    state.sp = sp;
211
    state.pc_address = StackFrame::ResolveReturnAddressLocation(
212
        reinterpret_cast<Address*>(StandardFrame::ComputePCAddress(fp)));
213 214 215 216
    // StackFrame::ComputeType will read both kContextOffset and kMarkerOffset,
    // we check only that kMarkerOffset is within the stack bounds and do
    // compile time check that kContextOffset slot is pushed on the stack before
    // kMarkerOffset.
217
    STATIC_ASSERT(StandardFrameConstants::kFunctionOffset <
218
                  StandardFrameConstants::kContextOffset);
219
    Address frame_marker = fp + StandardFrameConstants::kFunctionOffset;
220 221 222 223 224 225 226 227 228 229
    if (IsValidStackAddress(frame_marker)) {
      type = StackFrame::ComputeType(this, &state);
      top_frame_type_ = type;
    } else {
      // Mark the frame as JAVA_SCRIPT if we cannot determine its type.
      // The frame anyways will be skipped.
      type = StackFrame::JAVA_SCRIPT;
      // Top frame is incomplete so we cannot reliably determine its type.
      top_frame_type_ = StackFrame::NONE;
    }
230 231 232 233
  } else {
    return;
  }
  frame_ = SingletonFor(type, &state);
234
  if (frame_) Advance();
235 236 237
}


238
bool SafeStackFrameIterator::IsValidTop(ThreadLocalTop* top) const {
239 240
  Address c_entry_fp = Isolate::c_entry_fp(top);
  if (!IsValidExitFrame(c_entry_fp)) return false;
241
  // There should be at least one JS_ENTRY stack handler.
242 243 244 245
  Address handler = Isolate::handler(top);
  if (handler == NULL) return false;
  // Check that there are no js frames on top of the native frames.
  return c_entry_fp < handler;
246 247 248
}


249
void SafeStackFrameIterator::AdvanceOneFrame() {
250
  DCHECK(!done());
251
  StackFrame* last_frame = frame_;
252
  Address last_sp = last_frame->sp(), last_fp = last_frame->fp();
253 254 255 256 257
  // Before advancing to the next stack frame, perform pointer validity tests.
  if (!IsValidFrame(last_frame) || !IsValidCaller(last_frame)) {
    frame_ = NULL;
    return;
  }
258

259 260 261 262
  // Advance to the previous frame.
  StackFrame::State state;
  StackFrame::Type type = frame_->GetCallerState(&state);
  frame_ = SingletonFor(type, &state);
263
  if (!frame_) return;
264 265 266 267 268

  // Check that we have actually moved to the previous frame in the stack.
  if (frame_->sp() < last_sp || frame_->fp() < last_fp) {
    frame_ = NULL;
  }
269 270 271 272
}


bool SafeStackFrameIterator::IsValidFrame(StackFrame* frame) const {
273
  return IsValidStackAddress(frame->sp()) && IsValidStackAddress(frame->fp());
274 275 276 277 278
}


bool SafeStackFrameIterator::IsValidCaller(StackFrame* frame) {
  StackFrame::State state;
279 280 281 282 283 284
  if (frame->is_entry() || frame->is_entry_construct()) {
    // See EntryFrame::GetCallerState. It computes the caller FP address
    // and calls ExitFrame::GetStateForFramePointer on it. We need to be
    // sure that caller FP address is valid.
    Address caller_fp = Memory::Address_at(
        frame->fp() + EntryFrameConstants::kCallerFPOffset);
285
    if (!IsValidExitFrame(caller_fp)) return false;
286 287 288 289 290 291 292 293 294 295
  } else if (frame->is_arguments_adaptor()) {
    // See ArgumentsAdaptorFrame::GetCallerStackPointer. It assumes that
    // the number of arguments is stored on stack as Smi. We need to check
    // that it really an Smi.
    Object* number_of_args = reinterpret_cast<ArgumentsAdaptorFrame*>(frame)->
        GetExpression(0);
    if (!number_of_args->IsSmi()) {
      return false;
    }
  }
296 297
  frame->ComputeCallerState(&state);
  return IsValidStackAddress(state.sp) && IsValidStackAddress(state.fp) &&
298 299 300 301 302 303 304 305 306 307 308
      SingletonFor(frame->GetCallerState(&state)) != NULL;
}


bool SafeStackFrameIterator::IsValidExitFrame(Address fp) const {
  if (!IsValidStackAddress(fp)) return false;
  Address sp = ExitFrame::ComputeStackPointer(fp);
  if (!IsValidStackAddress(sp)) return false;
  StackFrame::State state;
  ExitFrame::FillState(fp, sp, &state);
  return *state.pc_address != NULL;
309 310 311
}


312
void SafeStackFrameIterator::Advance() {
313
  while (true) {
314
    AdvanceOneFrame();
315 316 317 318 319 320 321 322 323 324 325 326 327 328
    if (done()) break;
    ExternalCallbackScope* last_callback_scope = NULL;
    while (external_callback_scope_ != NULL &&
           external_callback_scope_->scope_address() < frame_->fp()) {
      // As long as the setup of a frame is not atomic, we may happen to be
      // in an interval where an ExternalCallbackScope is already created,
      // but the frame is not yet entered. So we are actually observing
      // the previous frame.
      // Skip all the ExternalCallbackScope's that are below the current fp.
      last_callback_scope = external_callback_scope_;
      external_callback_scope_ = external_callback_scope_->previous();
    }
    if (frame_->is_java_script()) break;
    if (frame_->is_exit()) {
329 330 331 332 333
      // Some of the EXIT frames may have ExternalCallbackScope allocated on
      // top of them. In that case the scope corresponds to the first EXIT
      // frame beneath it. There may be other EXIT frames on top of the
      // ExternalCallbackScope, just skip them as we cannot collect any useful
      // information about them.
334
      if (last_callback_scope) {
335
        frame_->state_.pc_address =
336
            last_callback_scope->callback_entrypoint_address();
337
      }
338
      break;
339
    }
340
  }
341 342 343
}


344 345 346
// -------------------------------------------------------------------------


347
Code* StackFrame::GetSafepointData(Isolate* isolate,
348
                                   Address inner_pointer,
349
                                   SafepointEntry* safepoint_entry,
350
                                   unsigned* stack_slots) {
351 352
  InnerPointerToCodeCache::InnerPointerToCodeCacheEntry* entry =
      isolate->inner_pointer_to_code_cache()->GetCacheEntry(inner_pointer);
353
  if (!entry->safepoint_entry.is_valid()) {
354
    entry->safepoint_entry = entry->code->GetSafepointEntry(inner_pointer);
355
    DCHECK(entry->safepoint_entry.is_valid());
356
  } else {
357
    DCHECK(entry->safepoint_entry.Equals(
358
        entry->code->GetSafepointEntry(inner_pointer)));
359 360 361 362
  }

  // Fill in the results and return the code.
  Code* code = entry->code;
363
  *safepoint_entry = entry->safepoint_entry;
364 365 366 367 368
  *stack_slots = code->stack_slots();
  return code;
}


369 370 371 372 373
#ifdef DEBUG
static bool GcSafeCodeContains(HeapObject* object, Address addr);
#endif


374 375
void StackFrame::IteratePc(ObjectVisitor* v, Address* pc_address,
                           Address* constant_pool_address, Code* holder) {
376
  Address pc = *pc_address;
377
  DCHECK(GcSafeCodeContains(holder, pc));
378
  unsigned pc_offset = static_cast<unsigned>(pc - holder->instruction_start());
379 380 381 382 383 384
  Object* code = holder;
  v->VisitPointer(&code);
  if (code != holder) {
    holder = reinterpret_cast<Code*>(code);
    pc = holder->instruction_start() + pc_offset;
    *pc_address = pc;
385 386 387
    if (FLAG_enable_embedded_constant_pool && constant_pool_address) {
      *constant_pool_address = holder->constant_pool();
    }
388 389 390 391
  }
}


392 393
void StackFrame::SetReturnAddressLocationResolver(
    ReturnAddressLocationResolver resolver) {
394
  DCHECK(return_address_location_resolver_ == NULL);
395
  return_address_location_resolver_ = resolver;
396 397
}

398 399 400 401 402 403 404 405 406 407 408
static bool IsInterpreterFramePc(Isolate* isolate, Address pc) {
  Code* interpreter_entry_trampoline =
      isolate->builtins()->builtin(Builtins::kInterpreterEntryTrampoline);
  Code* interpreter_bytecode_dispatch =
      isolate->builtins()->builtin(Builtins::kInterpreterEnterBytecodeDispatch);

  return (pc >= interpreter_entry_trampoline->instruction_start() &&
          pc < interpreter_entry_trampoline->instruction_end()) ||
         (pc >= interpreter_bytecode_dispatch->instruction_start() &&
          pc < interpreter_bytecode_dispatch->instruction_end());
}
409

410
StackFrame::Type StackFrame::ComputeType(const StackFrameIteratorBase* iterator,
411
                                         State* state) {
412
  DCHECK(state->fp != NULL);
413

danno's avatar
danno committed
414 415 416 417 418
#if defined(USE_SIMULATOR)
  MSAN_MEMORY_IS_INITIALIZED(
      state->fp + CommonFrameConstants::kContextOrFrameTypeOffset,
      kPointerSize);
#endif
419 420
  Object* marker = Memory::Object_at(
      state->fp + CommonFrameConstants::kContextOrFrameTypeOffset);
421 422 423 424 425 426
  if (!iterator->can_access_heap_objects_) {
    // TODO(titzer): "can_access_heap_objects" is kind of bogus. It really
    // means that we are being called from the profiler, which can interrupt
    // the VM with a signal at any arbitrary instruction, with essentially
    // anything on the stack. So basically none of these checks are 100%
    // reliable.
427 428
#if defined(USE_SIMULATOR)
    MSAN_MEMORY_IS_INITIALIZED(
danno's avatar
danno committed
429
        state->fp + StandardFrameConstants::kFunctionOffset, kPointerSize);
430
#endif
431 432 433 434 435 436 437 438 439 440 441
    Object* maybe_function =
        Memory::Object_at(state->fp + StandardFrameConstants::kFunctionOffset);
    if (!marker->IsSmi()) {
      if (maybe_function->IsSmi()) {
        return NONE;
      } else if (FLAG_ignition && IsInterpreterFramePc(iterator->isolate(),
                                                       *(state->pc_address))) {
        return INTERPRETED;
      } else {
        return JAVA_SCRIPT;
      }
442
    }
443 444 445 446 447 448 449 450 451 452
  } else {
    // Look up the code object to figure out the type of the stack frame.
    Code* code_obj =
        GetContainingCode(iterator->isolate(), *(state->pc_address));
    if (code_obj != nullptr) {
      if (code_obj->is_interpreter_entry_trampoline() ||
          code_obj->is_interpreter_enter_bytecode_dispatch()) {
        return INTERPRETED;
      }
      switch (code_obj->kind()) {
453 454 455 456 457 458
        case Code::BUILTIN:
          if (marker->IsSmi()) break;
          // We treat frames for BUILTIN Code objects as OptimizedFrame for now
          // (all the builtins with JavaScript linkage are actually generated
          // with TurboFan currently, so this is sound).
          return OPTIMIZED;
459 460 461 462 463 464 465 466 467 468 469 470 471 472
        case Code::FUNCTION:
          return JAVA_SCRIPT;
        case Code::OPTIMIZED_FUNCTION:
          return OPTIMIZED;
        case Code::WASM_FUNCTION:
          return WASM;
        case Code::WASM_TO_JS_FUNCTION:
          return WASM_TO_JS;
        case Code::JS_TO_WASM_FUNCTION:
          return JS_TO_WASM;
        default:
          // All other types should have an explicit marker
          break;
      }
473
    } else {
474
      return NONE;
475
    }
476
  }
477

478 479 480 481 482 483 484 485 486 487 488 489 490 491
  DCHECK(marker->IsSmi());
  StackFrame::Type candidate =
      static_cast<StackFrame::Type>(Smi::cast(marker)->value());
  switch (candidate) {
    case ENTRY:
    case ENTRY_CONSTRUCT:
    case EXIT:
    case STUB:
    case STUB_FAILURE_TRAMPOLINE:
    case INTERNAL:
    case CONSTRUCT:
    case ARGUMENTS_ADAPTOR:
    case WASM_TO_JS:
    case WASM:
492 493
      return candidate;
    case JS_TO_WASM:
494 495 496 497 498 499 500 501 502
    case JAVA_SCRIPT:
    case OPTIMIZED:
    case INTERPRETED:
    default:
      // Unoptimized and optimized JavaScript frames, including
      // interpreted frames, should never have a StackFrame::Type
      // marker. If we find one, we're likely being called from the
      // profiler in a bogus stack frame.
      return NONE;
503
  }
504 505 506
}


507 508 509 510 511 512
#ifdef DEBUG
bool StackFrame::can_access_heap_objects() const {
  return iterator_->can_access_heap_objects_;
}
#endif

513

514 515
StackFrame::Type StackFrame::GetCallerState(State* state) const {
  ComputeCallerState(state);
516
  return ComputeType(iterator_, state);
517 518 519
}


520 521 522 523 524
Address StackFrame::UnpaddedFP() const {
  return fp();
}


525
Code* EntryFrame::unchecked_code() const {
526
  return isolate()->heap()->js_entry_code();
527 528 529
}


530 531 532 533 534
void EntryFrame::ComputeCallerState(State* state) const {
  GetCallerState(state);
}


535 536 537 538 539 540
void EntryFrame::SetCallerFp(Address caller_fp) {
  const int offset = EntryFrameConstants::kCallerFPOffset;
  Memory::Address_at(this->fp() + offset) = caller_fp;
}


541 542 543 544 545 546 547
StackFrame::Type EntryFrame::GetCallerState(State* state) const {
  const int offset = EntryFrameConstants::kCallerFPOffset;
  Address fp = Memory::Address_at(this->fp() + offset);
  return ExitFrame::GetStateForFramePointer(fp, state);
}


548
Code* EntryConstructFrame::unchecked_code() const {
549
  return isolate()->heap()->js_construct_entry_code();
550 551 552
}


553 554 555 556 557 558
Object*& ExitFrame::code_slot() const {
  const int offset = ExitFrameConstants::kCodeOffset;
  return Memory::Object_at(fp() + offset);
}


559 560
Code* ExitFrame::unchecked_code() const {
  return reinterpret_cast<Code*>(code_slot());
561 562 563
}


564
void ExitFrame::ComputeCallerState(State* state) const {
565
  // Set up the caller state.
566
  state->sp = caller_sp();
567
  state->fp = Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset);
568 569
  state->pc_address = ResolveReturnAddressLocation(
      reinterpret_cast<Address*>(fp() + ExitFrameConstants::kCallerPCOffset));
570
  if (FLAG_enable_embedded_constant_pool) {
571 572 573
    state->constant_pool_address = reinterpret_cast<Address*>(
        fp() + ExitFrameConstants::kConstantPoolOffset);
  }
574 575 576
}


577 578 579 580 581
void ExitFrame::SetCallerFp(Address caller_fp) {
  Memory::Address_at(fp() + ExitFrameConstants::kCallerFPOffset) = caller_fp;
}


582 583 584
void ExitFrame::Iterate(ObjectVisitor* v) const {
  // The arguments are traversed as part of the expression stack of
  // the calling frame.
585
  IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
586 587 588 589
  v->VisitPointer(&code_slot());
}


590
Address ExitFrame::GetCallerStackPointer() const {
591
  return fp() + ExitFrameConstants::kCallerSPOffset;
592 593 594
}


595 596 597 598
StackFrame::Type ExitFrame::GetStateForFramePointer(Address fp, State* state) {
  if (fp == 0) return NONE;
  Address sp = ComputeStackPointer(fp);
  FillState(fp, sp, state);
599
  DCHECK(*state->pc_address != NULL);
600 601 602 603
  return EXIT;
}


604 605 606 607 608
Address ExitFrame::ComputeStackPointer(Address fp) {
  return Memory::Address_at(fp + ExitFrameConstants::kSPOffset);
}


609 610 611
void ExitFrame::FillState(Address fp, Address sp, State* state) {
  state->sp = sp;
  state->fp = fp;
612
  state->pc_address = ResolveReturnAddressLocation(
613
      reinterpret_cast<Address*>(sp - 1 * kPCOnStackSize));
614 615 616 617 618
  // The constant pool recorded in the exit frame is not associated
  // with the pc in this state (the return address into a C entry
  // stub).  ComputeCallerState will retrieve the constant pool
  // together with the associated caller pc.
  state->constant_pool_address = NULL;
619 620
}

621
Address StandardFrame::GetExpressionAddress(int n) const {
622 623
  const int offset = StandardFrameConstants::kExpressionsOffset;
  return fp() + offset - n * kPointerSize;
624 625
}

626 627 628
Address InterpretedFrame::GetExpressionAddress(int n) const {
  const int offset = InterpreterFrameConstants::kExpressionsOffset;
  return fp() + offset - n * kPointerSize;
629 630
}

631
int StandardFrame::ComputeExpressionsCount() const {
632 633
  Address base = GetExpressionAddress(0);
  Address limit = sp() - kPointerSize;
634
  DCHECK(base >= limit);  // stack grows downwards
635
  // Include register-allocated locals in number of expressions.
636
  return static_cast<int>((base - limit) / kPointerSize);
637 638 639
}


640
void StandardFrame::ComputeCallerState(State* state) const {
641 642
  state->sp = caller_sp();
  state->fp = caller_fp();
643 644
  state->pc_address = ResolveReturnAddressLocation(
      reinterpret_cast<Address*>(ComputePCAddress(fp())));
645 646
  state->constant_pool_address =
      reinterpret_cast<Address*>(ComputeConstantPoolAddress(fp()));
647 648 649
}


650 651 652 653 654 655
void StandardFrame::SetCallerFp(Address caller_fp) {
  Memory::Address_at(fp() + StandardFrameConstants::kCallerFPOffset) =
      caller_fp;
}


656
void StandardFrame::IterateCompiledFrame(ObjectVisitor* v) const {
657 658
  // Make sure that we're not doing "safe" stack frame iteration. We cannot
  // possibly find pointers in optimized frames in that state.
659
  DCHECK(can_access_heap_objects());
660 661 662

  // Compute the safepoint information.
  unsigned stack_slots = 0;
663
  SafepointEntry safepoint_entry;
664
  Code* code = StackFrame::GetSafepointData(
665
      isolate(), pc(), &safepoint_entry, &stack_slots);
666 667 668 669
  unsigned slot_space = stack_slots * kPointerSize;

  // Determine the fixed header and spill slot area size.
  int frame_header_size = StandardFrameConstants::kFixedFrameSizeFromFp;
670 671
  Object* marker =
      Memory::Object_at(fp() + CommonFrameConstants::kContextOrFrameTypeOffset);
672 673 674 675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690 691 692 693 694 695 696 697 698 699 700 701 702 703 704
  if (marker->IsSmi()) {
    StackFrame::Type candidate =
        static_cast<StackFrame::Type>(Smi::cast(marker)->value());
    switch (candidate) {
      case ENTRY:
      case ENTRY_CONSTRUCT:
      case EXIT:
      case STUB_FAILURE_TRAMPOLINE:
      case ARGUMENTS_ADAPTOR:
      case STUB:
      case INTERNAL:
      case CONSTRUCT:
      case JS_TO_WASM:
      case WASM_TO_JS:
      case WASM:
        frame_header_size = TypedFrameConstants::kFixedFrameSizeFromFp;
        break;
      case JAVA_SCRIPT:
      case OPTIMIZED:
      case INTERPRETED:
        // These frame types have a context, but they are actually stored
        // in the place on the stack that one finds the frame type.
        UNREACHABLE();
        break;
      case NONE:
      case NUMBER_OF_TYPES:
      case MANUAL:
        UNREACHABLE();
        break;
    }
  }
  slot_space -=
      (frame_header_size + StandardFrameConstants::kFixedFrameSizeAboveFp);
705

706
  Object** frame_header_base = &Memory::Object_at(fp() - frame_header_size);
707 708
  Object** frame_header_limit =
      &Memory::Object_at(fp() - StandardFrameConstants::kCPSlotSize);
709
  Object** parameters_base = &Memory::Object_at(sp());
710
  Object** parameters_limit = frame_header_base - slot_space / kPointerSize;
711

712 713 714 715 716 717 718
  // Visit the parameters that may be on top of the saved registers.
  if (safepoint_entry.argument_count() > 0) {
    v->VisitPointers(parameters_base,
                     parameters_base + safepoint_entry.argument_count());
    parameters_base += safepoint_entry.argument_count();
  }

719
  // Skip saved double registers.
720
  if (safepoint_entry.has_doubles()) {
721
    // Number of doubles not known at snapshot time.
722
    DCHECK(!isolate()->serializer_enabled());
723 724 725 726
    parameters_base +=
        RegisterConfiguration::ArchDefault(RegisterConfiguration::CRANKSHAFT)
            ->num_allocatable_double_registers() *
        kDoubleSize / kPointerSize;
727 728
  }

729
  // Visit the registers that contain pointers if any.
730
  if (safepoint_entry.HasRegisters()) {
731
    for (int i = kNumSafepointRegisters - 1; i >=0; i--) {
732
      if (safepoint_entry.HasRegisterAt(i)) {
733 734 735 736 737 738 739 740 741
        int reg_stack_index = MacroAssembler::SafepointRegisterStackIndex(i);
        v->VisitPointer(parameters_base + reg_stack_index);
      }
    }
    // Skip the words containing the register values.
    parameters_base += kNumSafepointRegisters;
  }

  // We're done dealing with the register bits.
742 743
  uint8_t* safepoint_bits = safepoint_entry.bits();
  safepoint_bits += kNumSafepointRegisters >> kBitsPerByteLog2;
744 745

  // Visit the rest of the parameters.
746 747 748 749
  if (!is_js_to_wasm() && !is_wasm()) {
    // Non-WASM frames have tagged values as parameters.
    v->VisitPointers(parameters_base, parameters_limit);
  }
750 751 752 753 754

  // Visit pointer spill slots and locals.
  for (unsigned index = 0; index < stack_slots; index++) {
    int byte_index = index >> kBitsPerByteLog2;
    int bit_index = index & (kBitsPerByte - 1);
755
    if ((safepoint_bits[byte_index] & (1U << bit_index)) != 0) {
756 757 758 759
      v->VisitPointer(parameters_limit + index);
    }
  }

760
  // Visit the return address in the callee and incoming arguments.
761
  IteratePc(v, pc_address(), constant_pool_address(), code);
762

763 764 765
  if (!is_wasm() && !is_wasm_to_js()) {
    // Visit the context in stub frame and JavaScript frame.
    // Visit the function in JavaScript frame.
766
    v->VisitPointers(frame_header_base, frame_header_limit);
767
  }
768 769 770 771 772 773 774 775 776
}


void StubFrame::Iterate(ObjectVisitor* v) const {
  IterateCompiledFrame(v);
}


Code* StubFrame::unchecked_code() const {
777
  return static_cast<Code*>(isolate()->FindCodeObject(pc()));
778 779 780 781
}


Address StubFrame::GetCallerStackPointer() const {
782
  return fp() + ExitFrameConstants::kCallerSPOffset;
783 784 785 786 787 788 789 790 791 792
}


int StubFrame::GetNumberOfIncomingArguments() const {
  return 0;
}


void OptimizedFrame::Iterate(ObjectVisitor* v) const {
  IterateCompiledFrame(v);
793 794 795
}


796 797 798 799 800
void JavaScriptFrame::SetParameterValue(int index, Object* value) const {
  Memory::Object_at(GetParameterSlot(index)) = value;
}


801
bool JavaScriptFrame::IsConstructor() const {
802 803 804 805 806 807
  Address fp = caller_fp();
  if (has_adapted_arguments()) {
    // Skip the arguments adaptor frame and look at the real caller.
    fp = Memory::Address_at(fp + StandardFrameConstants::kCallerFPOffset);
  }
  return IsConstructFrame(fp);
808 809 810
}


811
bool JavaScriptFrame::HasInlinedFrames() const {
812 813 814 815 816 817
  List<JSFunction*> functions(1);
  GetFunctions(&functions);
  return functions.length() > 1;
}


818 819 820
int JavaScriptFrame::GetArgumentsLength() const {
  // If there is an arguments adaptor frame get the arguments length from it.
  if (has_adapted_arguments()) {
821
    return ArgumentsAdaptorFrame::GetLength(caller_fp());
822 823 824 825 826 827
  } else {
    return GetNumberOfIncomingArguments();
  }
}


828
Code* JavaScriptFrame::unchecked_code() const {
829
  return function()->code();
830 831 832
}


833
int JavaScriptFrame::GetNumberOfIncomingArguments() const {
834
  DCHECK(can_access_heap_objects() &&
835 836
         isolate()->heap()->gc_state() == Heap::NOT_IN_GC);

837
  return function()->shared()->internal_formal_parameter_count();
838 839 840
}


841
Address JavaScriptFrame::GetCallerStackPointer() const {
842
  return fp() + StandardFrameConstants::kCallerSPOffset;
843 844 845
}


846
void JavaScriptFrame::GetFunctions(List<JSFunction*>* functions) const {
847
  DCHECK(functions->length() == 0);
848
  functions->Add(function());
849 850
}

851 852
void JavaScriptFrame::Summarize(List<FrameSummary>* functions,
                                FrameSummary::Mode mode) const {
853
  DCHECK(functions->length() == 0);
854 855 856 857
  Code* code = LookupCode();
  int offset = static_cast<int>(pc() - code->instruction_start());
  AbstractCode* abstract_code = AbstractCode::cast(code);
  FrameSummary summary(receiver(), function(), abstract_code, offset,
858
                       IsConstructor(), mode);
859 860 861
  functions->Add(summary);
}

862 863 864 865 866 867
JSFunction* JavaScriptFrame::function() const {
  return JSFunction::cast(function_slot_object());
}

Object* JavaScriptFrame::receiver() const { return GetParameter(-1); }

868
int JavaScriptFrame::LookupExceptionHandlerInTable(
869
    int* stack_depth, HandlerTable::CatchPrediction* prediction) {
870 871 872 873
  Code* code = LookupCode();
  DCHECK(!code->is_optimized_code());
  HandlerTable* table = HandlerTable::cast(code->handler_table());
  int pc_offset = static_cast<int>(pc() - code->entry());
874
  return table->LookupRange(pc_offset, stack_depth, prediction);
875 876 877
}


878 879 880 881 882 883 884 885 886
void JavaScriptFrame::PrintFunctionAndOffset(JSFunction* function, Code* code,
                                             Address pc, FILE* file,
                                             bool print_line_number) {
  PrintF(file, "%s", function->IsOptimized() ? "*" : "~");
  function->PrintName(file);
  int code_offset = static_cast<int>(pc - code->instruction_start());
  PrintF(file, "+%d", code_offset);
  if (print_line_number) {
    SharedFunctionInfo* shared = function->shared();
887
    int source_pos = code->SourcePosition(code_offset);
888 889 890 891 892 893 894
    Object* maybe_script = shared->script();
    if (maybe_script->IsScript()) {
      Script* script = Script::cast(maybe_script);
      int line = script->GetLineNumber(source_pos) + 1;
      Object* script_name_raw = script->name();
      if (script_name_raw->IsString()) {
        String* script_name = String::cast(script->name());
rmcilroy's avatar
rmcilroy committed
895
        base::SmartArrayPointer<char> c_script_name =
896 897 898 899 900 901 902 903 904 905 906 907 908
            script_name->ToCString(DISALLOW_NULLS, ROBUST_STRING_TRAVERSAL);
        PrintF(file, " at %s:%d", c_script_name.get(), line);
      } else {
        PrintF(file, " at <unknown>:%d", line);
      }
    } else {
      PrintF(file, " at <unknown>:<unknown>");
    }
  }
}


void JavaScriptFrame::PrintTop(Isolate* isolate, FILE* file, bool print_args,
909 910
                               bool print_line_number) {
  // constructor calls
911
  DisallowHeapAllocation no_allocation;
912
  JavaScriptFrameIterator it(isolate);
913 914 915 916
  while (!it.done()) {
    if (it.frame()->is_java_script()) {
      JavaScriptFrame* frame = it.frame();
      if (frame->IsConstructor()) PrintF(file, "new ");
917 918
      PrintFunctionAndOffset(frame->function(), frame->unchecked_code(),
                             frame->pc(), file, print_line_number);
919 920 921 922 923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938
      if (print_args) {
        // function arguments
        // (we are intentionally only printing the actually
        // supplied parameters, not all parameters required)
        PrintF(file, "(this=");
        frame->receiver()->ShortPrint(file);
        const int length = frame->ComputeParametersCount();
        for (int i = 0; i < length; i++) {
          PrintF(file, ", ");
          frame->GetParameter(i)->ShortPrint(file);
        }
        PrintF(file, ")");
      }
      break;
    }
    it.Advance();
  }
}


939
void JavaScriptFrame::SaveOperandStack(FixedArray* store) const {
940
  int operands_count = store->length();
941
  DCHECK_LE(operands_count, ComputeOperandsCount());
942
  for (int i = 0; i < operands_count; i++) {
943 944 945 946
    store->set(i, GetOperand(i));
  }
}

947 948 949 950 951 952 953 954 955
namespace {

bool CannotDeoptFromAsmCode(Code* code, JSFunction* function) {
  return code->is_turbofanned() && function->shared()->asm_function() &&
         !FLAG_turbo_asm_deoptimization;
}

}  // namespace

956 957
FrameSummary::FrameSummary(Object* receiver, JSFunction* function,
                           AbstractCode* abstract_code, int code_offset,
958
                           bool is_constructor, Mode mode)
959 960
    : receiver_(receiver, function->GetIsolate()),
      function_(function),
961 962
      abstract_code_(abstract_code),
      code_offset_(code_offset),
963 964 965
      is_constructor_(is_constructor) {
  DCHECK(abstract_code->IsBytecodeArray() ||
         Code::cast(abstract_code)->kind() != Code::OPTIMIZED_FUNCTION ||
966 967
         CannotDeoptFromAsmCode(Code::cast(abstract_code), function) ||
         mode == kApproximateSummary);
968
}
969

970 971 972 973 974 975
FrameSummary FrameSummary::GetFirst(JavaScriptFrame* frame) {
  List<FrameSummary> frames(FLAG_max_inlining_levels + 1);
  frame->Summarize(&frames);
  return frames.first();
}

976 977 978 979 980 981
void FrameSummary::Print() {
  PrintF("receiver: ");
  receiver_->ShortPrint();
  PrintF("\nfunction: ");
  function_->shared()->DebugName()->ShortPrint();
  PrintF("\ncode: ");
982 983 984 985
  abstract_code_->ShortPrint();
  if (abstract_code_->IsCode()) {
    Code* code = abstract_code_->GetCode();
    if (code->kind() == Code::FUNCTION) PrintF(" UNOPT ");
986
    if (code->kind() == Code::OPTIMIZED_FUNCTION) {
987 988 989 990 991 992
      if (function()->shared()->asm_function()) {
        DCHECK(CannotDeoptFromAsmCode(code, *function()));
        PrintF(" ASM ");
      } else {
        PrintF(" OPT (approximate)");
      }
993
    }
994 995 996 997
  } else {
    PrintF(" BYTECODE ");
  }
  PrintF("\npc: %d\n", code_offset_);
998 999
}

1000 1001
void OptimizedFrame::Summarize(List<FrameSummary>* frames,
                               FrameSummary::Mode mode) const {
1002 1003
  DCHECK(frames->length() == 0);
  DCHECK(is_optimized());
1004

1005 1006
  // Delegate to JS frame in absence of turbofan deoptimization.
  // TODO(turbofan): Revisit once we support deoptimization across the board.
1007 1008
  Code* code = LookupCode();
  if (code->kind() == Code::BUILTIN ||
1009
      CannotDeoptFromAsmCode(code, function())) {
1010 1011 1012
    return JavaScriptFrame::Summarize(frames);
  }

1013 1014 1015
  DisallowHeapAllocation no_gc;
  int deopt_index = Safepoint::kNoDeoptimizationIndex;
  DeoptimizationInputData* const data = GetDeoptimizationData(&deopt_index);
1016 1017 1018 1019 1020 1021 1022
  if (deopt_index == Safepoint::kNoDeoptimizationIndex) {
    DCHECK(data == nullptr);
    if (mode == FrameSummary::kApproximateSummary) {
      return JavaScriptFrame::Summarize(frames, mode);
    }
    FATAL("Missing deoptimization information for OptimizedFrame::Summarize.");
  }
1023 1024 1025 1026
  FixedArray* const literal_array = data->LiteralArray();

  TranslationIterator it(data->TranslationByteArray(),
                         data->TranslationIndex(deopt_index)->value());
1027 1028 1029
  Translation::Opcode frame_opcode =
      static_cast<Translation::Opcode>(it.Next());
  DCHECK_EQ(Translation::BEGIN, frame_opcode);
1030 1031 1032
  it.Next();  // Drop frame count.
  int jsframe_count = it.Next();

1033 1034
  // We create the summary in reverse order because the frames
  // in the deoptimization translation are ordered bottom-to-top.
1035
  bool is_constructor = IsConstructor();
1036
  while (jsframe_count != 0) {
1037 1038 1039
    frame_opcode = static_cast<Translation::Opcode>(it.Next());
    if (frame_opcode == Translation::JS_FRAME ||
        frame_opcode == Translation::INTERPRETED_FRAME) {
1040
      jsframe_count--;
1041
      BailoutId const bailout_id = BailoutId(it.Next());
1042 1043 1044 1045 1046 1047
      SharedFunctionInfo* const shared_info =
          SharedFunctionInfo::cast(literal_array->get(it.Next()));
      it.Next();  // Skip height.

      // The translation commands are ordered and the function is always
      // at the first position, and the receiver is next.
1048
      Translation::Opcode opcode = static_cast<Translation::Opcode>(it.Next());
1049 1050 1051 1052 1053 1054

      // Get the correct function in the optimized frame.
      JSFunction* function;
      if (opcode == Translation::LITERAL) {
        function = JSFunction::cast(literal_array->get(it.Next()));
      } else {
1055 1056
        CHECK_EQ(opcode, Translation::STACK_SLOT);
        function = JSFunction::cast(StackSlotAt(it.Next()));
1057
      }
1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077
      DCHECK_EQ(shared_info, function->shared());

      // If we are at a call, the receiver is always in a stack slot.
      // Otherwise we are not guaranteed to get the receiver value.
      opcode = static_cast<Translation::Opcode>(it.Next());

      // Get the correct receiver in the optimized frame.
      Object* receiver;
      if (opcode == Translation::LITERAL) {
        receiver = literal_array->get(it.Next());
      } else if (opcode == Translation::STACK_SLOT) {
        receiver = StackSlotAt(it.Next());
      } else {
        // The receiver is not in a stack slot nor in a literal.  We give up.
        it.Skip(Translation::NumberOfOperandsFor(opcode));
        // TODO(3029): Materializing a captured object (or duplicated
        // object) is hard, we return undefined for now. This breaks the
        // produced stack trace, as constructor frames aren't marked as
        // such anymore.
        receiver = isolate()->heap()->undefined_value();
1078 1079
      }

1080
      AbstractCode* abstract_code;
1081

1082
      unsigned code_offset;
1083
      if (frame_opcode == Translation::JS_FRAME) {
1084
        Code* code = shared_info->code();
1085 1086 1087
        DeoptimizationOutputData* const output_data =
            DeoptimizationOutputData::cast(code->deoptimization_data());
        unsigned const entry =
1088
            Deoptimizer::GetOutputInfo(output_data, bailout_id, shared_info);
1089 1090
        code_offset = FullCodeGenerator::PcField::decode(entry);
        abstract_code = AbstractCode::cast(code);
1091 1092
      } else {
        DCHECK_EQ(frame_opcode, Translation::INTERPRETED_FRAME);
1093 1094 1095
        // BailoutId points to the next bytecode in the bytecode aray. Subtract
        // 1 to get the end of current bytecode.
        code_offset = bailout_id.ToInt() - 1;
1096
        abstract_code = AbstractCode::cast(shared_info->bytecode_array());
1097
      }
1098 1099
      FrameSummary summary(receiver, function, abstract_code, code_offset,
                           is_constructor);
1100 1101
      frames->Add(summary);
      is_constructor = false;
1102
    } else if (frame_opcode == Translation::CONSTRUCT_STUB_FRAME) {
1103
      // The next encountered JS_FRAME will be marked as a constructor call.
1104
      it.Skip(Translation::NumberOfOperandsFor(frame_opcode));
1105 1106 1107 1108
      DCHECK(!is_constructor);
      is_constructor = true;
    } else {
      // Skip over operands to advance to the next opcode.
1109
      it.Skip(Translation::NumberOfOperandsFor(frame_opcode));
1110 1111
    }
  }
1112
  DCHECK(!is_constructor);
1113 1114 1115
}


1116 1117
int OptimizedFrame::LookupExceptionHandlerInTable(
    int* stack_slots, HandlerTable::CatchPrediction* prediction) {
1118 1119 1120
  Code* code = LookupCode();
  HandlerTable* table = HandlerTable::cast(code->handler_table());
  int pc_offset = static_cast<int>(pc() - code->entry());
1121
  if (stack_slots) *stack_slots = code->stack_slots();
1122
  return table->LookupReturn(pc_offset, prediction);
1123 1124 1125
}


1126
DeoptimizationInputData* OptimizedFrame::GetDeoptimizationData(
1127
    int* deopt_index) const {
1128
  DCHECK(is_optimized());
1129

1130
  JSFunction* opt_function = function();
1131 1132 1133 1134 1135 1136
  Code* code = opt_function->code();

  // The code object may have been replaced by lazy deoptimization. Fall
  // back to a slow search in this case to find the original optimized
  // code object.
  if (!code->contains(pc())) {
1137 1138
    code = isolate()->inner_pointer_to_code_cache()->
        GcSafeFindCodeForInnerPointer(pc());
1139
  }
1140 1141
  DCHECK(code != NULL);
  DCHECK(code->kind() == Code::OPTIMIZED_FUNCTION);
1142

1143 1144
  SafepointEntry safepoint_entry = code->GetSafepointEntry(pc());
  *deopt_index = safepoint_entry.deoptimization_index();
1145 1146 1147 1148
  if (*deopt_index != Safepoint::kNoDeoptimizationIndex) {
    return DeoptimizationInputData::cast(code->deoptimization_data());
  }
  return nullptr;
1149 1150 1151
}


1152
void OptimizedFrame::GetFunctions(List<JSFunction*>* functions) const {
1153 1154
  DCHECK(functions->length() == 0);
  DCHECK(is_optimized());
1155

1156 1157
  // Delegate to JS frame in absence of turbofan deoptimization.
  // TODO(turbofan): Revisit once we support deoptimization across the board.
1158 1159 1160
  Code* code = LookupCode();
  if (code->kind() == Code::BUILTIN ||
      CannotDeoptFromAsmCode(code, function())) {
1161 1162 1163
    return JavaScriptFrame::GetFunctions(functions);
  }

1164
  DisallowHeapAllocation no_gc;
1165 1166
  int deopt_index = Safepoint::kNoDeoptimizationIndex;
  DeoptimizationInputData* const data = GetDeoptimizationData(&deopt_index);
1167 1168
  DCHECK_NOT_NULL(data);
  DCHECK_NE(Safepoint::kNoDeoptimizationIndex, deopt_index);
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179 1180 1181 1182 1183
  FixedArray* const literal_array = data->LiteralArray();

  TranslationIterator it(data->TranslationByteArray(),
                         data->TranslationIndex(deopt_index)->value());
  Translation::Opcode opcode = static_cast<Translation::Opcode>(it.Next());
  DCHECK_EQ(Translation::BEGIN, opcode);
  it.Next();  // Skip frame count.
  int jsframe_count = it.Next();

  // We insert the frames in reverse order because the frames
  // in the deoptimization translation are ordered bottom-to-top.
  while (jsframe_count != 0) {
    opcode = static_cast<Translation::Opcode>(it.Next());
    // Skip over operands to advance to the next opcode.
    it.Skip(Translation::NumberOfOperandsFor(opcode));
1184 1185
    if (opcode == Translation::JS_FRAME ||
        opcode == Translation::INTERPRETED_FRAME) {
1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196
      jsframe_count--;

      // The translation commands are ordered and the function is always at the
      // first position.
      opcode = static_cast<Translation::Opcode>(it.Next());

      // Get the correct function in the optimized frame.
      Object* function;
      if (opcode == Translation::LITERAL) {
        function = literal_array->get(it.Next());
      } else {
1197 1198
        CHECK_EQ(Translation::STACK_SLOT, opcode);
        function = StackSlotAt(it.Next());
1199 1200
      }
      functions->Add(JSFunction::cast(function));
1201 1202 1203 1204 1205
    }
  }
}


1206 1207 1208 1209 1210 1211
int OptimizedFrame::StackSlotOffsetRelativeToFp(int slot_index) {
  return StandardFrameConstants::kCallerSPOffset -
         ((slot_index + 1) * kPointerSize);
}


1212
Object* OptimizedFrame::StackSlotAt(int index) const {
1213
  return Memory::Object_at(fp() + StackSlotOffsetRelativeToFp(index));
1214 1215
}

1216
int InterpretedFrame::LookupExceptionHandlerInTable(
1217
    int* context_register, HandlerTable::CatchPrediction* prediction) {
1218 1219 1220
  BytecodeArray* bytecode = function()->shared()->bytecode_array();
  HandlerTable* table = HandlerTable::cast(bytecode->handler_table());
  int pc_offset = GetBytecodeOffset() + 1;  // Point after current bytecode.
1221
  return table->LookupRange(pc_offset, context_register, prediction);
1222 1223 1224 1225
}

int InterpretedFrame::GetBytecodeOffset() const {
  const int index = InterpreterFrameConstants::kBytecodeOffsetExpressionIndex;
1226 1227 1228
  DCHECK_EQ(
      InterpreterFrameConstants::kBytecodeOffsetFromFp,
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
1229 1230 1231 1232 1233 1234
  int raw_offset = Smi::cast(GetExpression(index))->value();
  return raw_offset - BytecodeArray::kHeaderSize + kHeapObjectTag;
}

void InterpretedFrame::PatchBytecodeOffset(int new_offset) {
  const int index = InterpreterFrameConstants::kBytecodeOffsetExpressionIndex;
1235 1236 1237
  DCHECK_EQ(
      InterpreterFrameConstants::kBytecodeOffsetFromFp,
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
1238 1239 1240 1241
  int raw_offset = new_offset + BytecodeArray::kHeaderSize - kHeapObjectTag;
  SetExpression(index, Smi::FromInt(raw_offset));
}

1242
BytecodeArray* InterpretedFrame::GetBytecodeArray() const {
1243
  const int index = InterpreterFrameConstants::kBytecodeArrayExpressionIndex;
1244 1245 1246
  DCHECK_EQ(
      InterpreterFrameConstants::kBytecodeArrayFromFp,
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
1247
  return BytecodeArray::cast(GetExpression(index));
1248 1249
}

1250
void InterpretedFrame::PatchBytecodeArray(BytecodeArray* bytecode_array) {
1251
  const int index = InterpreterFrameConstants::kBytecodeArrayExpressionIndex;
1252 1253 1254
  DCHECK_EQ(
      InterpreterFrameConstants::kBytecodeArrayFromFp,
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
1255
  SetExpression(index, bytecode_array);
1256 1257
}

1258
Object* InterpretedFrame::ReadInterpreterRegister(int register_index) const {
1259
  const int index = InterpreterFrameConstants::kRegisterFileExpressionIndex;
1260
  DCHECK_EQ(
1261
      InterpreterFrameConstants::kRegisterFileFromFp,
1262
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
1263
  return GetExpression(index + register_index);
1264 1265
}

1266 1267 1268 1269
void InterpretedFrame::WriteInterpreterRegister(int register_index,
                                                Object* value) {
  const int index = InterpreterFrameConstants::kRegisterFileExpressionIndex;
  DCHECK_EQ(
1270
      InterpreterFrameConstants::kRegisterFileFromFp,
1271 1272 1273 1274
      InterpreterFrameConstants::kExpressionsOffset - index * kPointerSize);
  return SetExpression(index + register_index, value);
}

1275 1276
void InterpretedFrame::Summarize(List<FrameSummary>* functions,
                                 FrameSummary::Mode mode) const {
1277 1278 1279 1280 1281 1282 1283
  DCHECK(functions->length() == 0);
  AbstractCode* abstract_code =
      AbstractCode::cast(function()->shared()->bytecode_array());
  FrameSummary summary(receiver(), function(), abstract_code,
                       GetBytecodeOffset(), IsConstructor());
  functions->Add(summary);
}
1284

1285 1286 1287 1288 1289
int ArgumentsAdaptorFrame::GetNumberOfIncomingArguments() const {
  return Smi::cast(GetExpression(0))->value();
}


1290
Address ArgumentsAdaptorFrame::GetCallerStackPointer() const {
1291
  return fp() + StandardFrameConstants::kCallerSPOffset;
1292 1293
}

1294 1295 1296
int ArgumentsAdaptorFrame::GetLength(Address fp) {
  const int offset = ArgumentsAdaptorFrameConstants::kLengthOffset;
  return Smi::cast(Memory::Object_at(fp + offset))->value();
1297 1298
}

1299
Code* ArgumentsAdaptorFrame::unchecked_code() const {
1300
  return isolate()->builtins()->builtin(
1301
      Builtins::kArgumentsAdaptorTrampoline);
1302 1303
}

1304 1305 1306 1307 1308
Address InternalFrame::GetCallerStackPointer() const {
  // Internal frames have no arguments. The stack pointer of the
  // caller is at a fixed offset from the frame pointer.
  return fp() + StandardFrameConstants::kCallerSPOffset;
}
1309

1310
Code* InternalFrame::unchecked_code() const {
1311 1312
  const int offset = InternalFrameConstants::kCodeOffset;
  Object* code = Memory::Object_at(fp() + offset);
1313
  DCHECK(code != NULL);
1314
  return reinterpret_cast<Code*>(code);
1315 1316 1317 1318 1319 1320 1321 1322 1323
}


void StackFrame::PrintIndex(StringStream* accumulator,
                            PrintMode mode,
                            int index) {
  accumulator->Add((mode == OVERVIEW) ? "%5d: " : "[%d]: ", index);
}

1324 1325 1326 1327 1328 1329 1330 1331 1332
void WasmFrame::Print(StringStream* accumulator, PrintMode mode,
                      int index) const {
  accumulator->Add("wasm frame");
}

Code* WasmFrame::unchecked_code() const {
  return static_cast<Code*>(isolate()->FindCodeObject(pc()));
}

1333 1334 1335 1336
void WasmFrame::Iterate(ObjectVisitor* v) const { IterateCompiledFrame(v); }

Address WasmFrame::GetCallerStackPointer() const {
  return fp() + ExitFrameConstants::kCallerSPOffset;
1337 1338
}

1339 1340 1341 1342
Object* WasmFrame::wasm_obj() {
  FixedArray* deopt_data = LookupCode()->deoptimization_data();
  DCHECK(deopt_data->length() == 2);
  return deopt_data->get(0);
1343 1344
}

1345 1346 1347 1348 1349 1350 1351 1352 1353 1354 1355 1356
uint32_t WasmFrame::function_index() {
  FixedArray* deopt_data = LookupCode()->deoptimization_data();
  DCHECK(deopt_data->length() == 2);
  Object* func_index_obj = deopt_data->get(1);
  if (func_index_obj->IsUndefined()) return static_cast<uint32_t>(-1);
  if (func_index_obj->IsSmi()) return Smi::cast(func_index_obj)->value();
  DCHECK(func_index_obj->IsHeapNumber());
  uint32_t val = static_cast<uint32_t>(-1);
  func_index_obj->ToUint32(&val);
  DCHECK(val != static_cast<uint32_t>(-1));
  return val;
}
1357

1358 1359 1360 1361 1362
Object* WasmFrame::function_name() {
  Object* wasm_object = wasm_obj();
  if (wasm_object->IsUndefined()) return wasm_object;
  Handle<JSObject> wasm = handle(JSObject::cast(wasm_object));
  return *wasm::GetWasmFunctionName(wasm, function_index());
1363
}
1364

jkummerow's avatar
jkummerow committed
1365 1366 1367 1368 1369 1370 1371 1372 1373 1374 1375 1376 1377 1378 1379 1380 1381 1382
namespace {


void PrintFunctionSource(StringStream* accumulator, SharedFunctionInfo* shared,
                         Code* code) {
  if (FLAG_max_stack_trace_source_length != 0 && code != NULL) {
    std::ostringstream os;
    os << "--------- s o u r c e   c o d e ---------\n"
       << SourceCodeOf(shared, FLAG_max_stack_trace_source_length)
       << "\n-----------------------------------------\n";
    accumulator->Add(os.str().c_str());
  }
}


}  // namespace


1383 1384 1385
void JavaScriptFrame::Print(StringStream* accumulator,
                            PrintMode mode,
                            int index) const {
1386
  DisallowHeapAllocation no_gc;
1387
  Object* receiver = this->receiver();
1388
  JSFunction* function = this->function();
1389 1390 1391 1392 1393 1394

  accumulator->PrintSecurityTokenIfChanged(function);
  PrintIndex(accumulator, mode, index);
  Code* code = NULL;
  if (IsConstructor()) accumulator->Add("new ");
  accumulator->PrintFunction(function, receiver, &code);
1395

1396 1397 1398 1399
  // Get scope information for nicer output, if possible. If code is NULL, or
  // doesn't contain scope info, scope_info will return 0 for the number of
  // parameters, stack local variables, context local variables, stack slots,
  // or context slots.
1400 1401
  SharedFunctionInfo* shared = function->shared();
  ScopeInfo* scope_info = shared->scope_info();
1402 1403
  Object* script_obj = shared->script();
  if (script_obj->IsScript()) {
1404
    Script* script = Script::cast(script_obj);
1405 1406 1407 1408 1409 1410
    accumulator->Add(" [");
    accumulator->PrintName(script->name());

    Address pc = this->pc();
    if (code != NULL && code->kind() == Code::FUNCTION &&
        pc >= code->instruction_start() && pc < code->instruction_end()) {
1411 1412
      int offset = static_cast<int>(pc - code->instruction_start());
      int source_pos = code->SourcePosition(offset);
1413
      int line = script->GetLineNumber(source_pos) + 1;
1414 1415 1416 1417 1418 1419 1420 1421 1422
      accumulator->Add(":%d] [pc=%p]", line, pc);
    } else if (is_interpreted()) {
      const InterpretedFrame* iframe =
          reinterpret_cast<const InterpretedFrame*>(this);
      BytecodeArray* bytecodes = iframe->GetBytecodeArray();
      int offset = iframe->GetBytecodeOffset();
      int source_pos = bytecodes->SourcePosition(offset);
      int line = script->GetLineNumber(source_pos) + 1;
      accumulator->Add(":%d] [bytecode=%p offset=%d]", line, bytecodes, offset);
1423 1424
    } else {
      int function_start_pos = shared->start_position();
1425
      int line = script->GetLineNumber(function_start_pos) + 1;
1426
      accumulator->Add(":~%d] [pc=%p]", line, pc);
1427 1428 1429
    }
  }

1430 1431 1432 1433 1434 1435 1436 1437 1438
  accumulator->Add("(this=%o", receiver);

  // Print the parameters.
  int parameters_count = ComputeParametersCount();
  for (int i = 0; i < parameters_count; i++) {
    accumulator->Add(",");
    // If we have a name for the parameter we print it. Nameless
    // parameters are either because we have more actual parameters
    // than formal parameters or because we have no scope information.
1439 1440
    if (i < scope_info->ParameterCount()) {
      accumulator->PrintName(scope_info->ParameterName(i));
1441 1442 1443 1444 1445 1446 1447 1448 1449 1450
      accumulator->Add("=");
    }
    accumulator->Add("%o", GetParameter(i));
  }

  accumulator->Add(")");
  if (mode == OVERVIEW) {
    accumulator->Add("\n");
    return;
  }
1451
  if (is_optimized()) {
jkummerow's avatar
jkummerow committed
1452 1453 1454
    accumulator->Add(" {\n// optimized frame\n");
    PrintFunctionSource(accumulator, shared, code);
    accumulator->Add("}\n");
1455 1456
    return;
  }
1457 1458 1459
  accumulator->Add(" {\n");

  // Compute the number of locals and expression stack elements.
1460 1461
  int stack_locals_count = scope_info->StackLocalCount();
  int heap_locals_count = scope_info->ContextLocalCount();
1462 1463 1464 1465 1466 1467 1468 1469
  int expressions_count = ComputeExpressionsCount();

  // Print stack-allocated local variables.
  if (stack_locals_count > 0) {
    accumulator->Add("  // stack-allocated locals\n");
  }
  for (int i = 0; i < stack_locals_count; i++) {
    accumulator->Add("  var ");
1470
    accumulator->PrintName(scope_info->StackLocalName(i));
1471 1472 1473 1474 1475 1476 1477 1478 1479 1480 1481 1482 1483 1484
    accumulator->Add(" = ");
    if (i < expressions_count) {
      accumulator->Add("%o", GetExpression(i));
    } else {
      accumulator->Add("// no expression found - inconsistent frame?");
    }
    accumulator->Add("\n");
  }

  // Try to get hold of the context of this frame.
  Context* context = NULL;
  if (this->context() != NULL && this->context()->IsContext()) {
    context = Context::cast(this->context());
  }
1485 1486
  while (context->IsWithContext()) {
    context = context->previous();
1487
    DCHECK(context != NULL);
1488
  }
1489 1490

  // Print heap-allocated local variables.
1491
  if (heap_locals_count > 0) {
1492 1493
    accumulator->Add("  // heap-allocated locals\n");
  }
1494
  for (int i = 0; i < heap_locals_count; i++) {
1495
    accumulator->Add("  var ");
1496
    accumulator->PrintName(scope_info->ContextLocalName(i));
1497 1498
    accumulator->Add(" = ");
    if (context != NULL) {
1499 1500 1501
      int index = Context::MIN_CONTEXT_SLOTS + i;
      if (index < context->length()) {
        accumulator->Add("%o", context->get(index));
1502 1503 1504 1505 1506 1507 1508 1509 1510 1511 1512
      } else {
        accumulator->Add(
            "// warning: missing context slot - inconsistent frame?");
      }
    } else {
      accumulator->Add("// warning: no context found - inconsistent frame?");
    }
    accumulator->Add("\n");
  }

  // Print the expression stack.
1513
  int expressions_start = stack_locals_count;
1514 1515 1516 1517 1518 1519 1520
  if (expressions_start < expressions_count) {
    accumulator->Add("  // expression stack (top to bottom)\n");
  }
  for (int i = expressions_count - 1; i >= expressions_start; i--) {
    accumulator->Add("  [%02d] : %o\n", i, GetExpression(i));
  }

jkummerow's avatar
jkummerow committed
1521
  PrintFunctionSource(accumulator, shared, code);
1522 1523 1524 1525 1526 1527 1528 1529 1530 1531

  accumulator->Add("}\n\n");
}


void ArgumentsAdaptorFrame::Print(StringStream* accumulator,
                                  PrintMode mode,
                                  int index) const {
  int actual = ComputeParametersCount();
  int expected = -1;
1532
  JSFunction* function = this->function();
1533
  expected = function->shared()->internal_formal_parameter_count();
1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556 1557

  PrintIndex(accumulator, mode, index);
  accumulator->Add("arguments adaptor frame: %d->%d", actual, expected);
  if (mode == OVERVIEW) {
    accumulator->Add("\n");
    return;
  }
  accumulator->Add(" {\n");

  // Print actual arguments.
  if (actual > 0) accumulator->Add("  // actual arguments\n");
  for (int i = 0; i < actual; i++) {
    accumulator->Add("  [%02d] : %o", i, GetParameter(i));
    if (expected != -1 && i >= expected) {
      accumulator->Add("  // not passed to callee");
    }
    accumulator->Add("\n");
  }

  accumulator->Add("}\n\n");
}


void EntryFrame::Iterate(ObjectVisitor* v) const {
1558
  IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
1559 1560 1561 1562
}


void StandardFrame::IterateExpressions(ObjectVisitor* v) const {
1563
  const int offset = StandardFrameConstants::kLastObjectOffset;
1564 1565 1566 1567 1568 1569 1570 1571
  Object** base = &Memory::Object_at(sp());
  Object** limit = &Memory::Object_at(fp() + offset) + 1;
  v->VisitPointers(base, limit);
}


void JavaScriptFrame::Iterate(ObjectVisitor* v) const {
  IterateExpressions(v);
1572
  IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
1573 1574 1575 1576 1577 1578
}

void InternalFrame::Iterate(ObjectVisitor* v) const {
  // Internal frames only have object pointers on the expression stack
  // as they never have any arguments.
  IterateExpressions(v);
1579
  IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
1580 1581 1582
}


1583 1584
void StubFailureTrampolineFrame::Iterate(ObjectVisitor* v) const {
  Object** base = &Memory::Object_at(sp());
1585 1586
  Object** limit = &Memory::Object_at(
      fp() + StubFailureTrampolineFrameConstants::kFixedHeaderBottomOffset);
1587
  v->VisitPointers(base, limit);
1588
  base = &Memory::Object_at(fp() + StandardFrameConstants::kFunctionOffset);
1589
  const int offset = StandardFrameConstants::kLastObjectOffset;
1590
  limit = &Memory::Object_at(fp() + offset) + 1;
1591
  v->VisitPointers(base, limit);
1592
  IteratePc(v, pc_address(), constant_pool_address(), LookupCode());
1593 1594 1595
}


1596 1597 1598 1599 1600 1601
Address StubFailureTrampolineFrame::GetCallerStackPointer() const {
  return fp() + StandardFrameConstants::kCallerSPOffset;
}


Code* StubFailureTrampolineFrame::unchecked_code() const {
1602
  Code* trampoline;
1603
  StubFailureTrampolineStub(isolate(), NOT_JS_FUNCTION_STUB_MODE).
1604
      FindCodeInCache(&trampoline);
1605 1606 1607 1608
  if (trampoline->contains(pc())) {
    return trampoline;
  }

1609
  StubFailureTrampolineStub(isolate(), JS_FUNCTION_STUB_MODE).
1610
      FindCodeInCache(&trampoline);
1611 1612
  if (trampoline->contains(pc())) {
    return trampoline;
1613
  }
1614

1615 1616 1617 1618 1619
  UNREACHABLE();
  return NULL;
}


1620 1621 1622 1623
// -------------------------------------------------------------------------


JavaScriptFrame* StackFrameLocator::FindJavaScriptFrame(int n) {
1624
  DCHECK(n >= 0);
1625 1626 1627 1628 1629 1630 1631 1632 1633 1634 1635 1636 1637
  for (int i = 0; i <= n; i++) {
    while (!iterator_.frame()->is_java_script()) iterator_.Advance();
    if (i == n) return JavaScriptFrame::cast(iterator_.frame());
    iterator_.Advance();
  }
  UNREACHABLE();
  return NULL;
}


// -------------------------------------------------------------------------


1638 1639 1640 1641
static Map* GcSafeMapOfCodeSpaceObject(HeapObject* object) {
  MapWord map_word = object->map_word();
  return map_word.IsForwardingAddress() ?
      map_word.ToForwardingAddress()->map() : map_word.ToMap();
1642 1643 1644
}


1645
static int GcSafeSizeOfCodeSpaceObject(HeapObject* object) {
1646 1647 1648 1649 1650 1651 1652
  return object->SizeFromMap(GcSafeMapOfCodeSpaceObject(object));
}


#ifdef DEBUG
static bool GcSafeCodeContains(HeapObject* code, Address addr) {
  Map* map = GcSafeMapOfCodeSpaceObject(code);
1653
  DCHECK(map == code->GetHeap()->code_map());
1654 1655 1656 1657 1658 1659 1660 1661 1662 1663
  Address start = code->address();
  Address end = code->address() + code->SizeFromMap(map);
  return start <= addr && addr < end;
}
#endif


Code* InnerPointerToCodeCache::GcSafeCastToCode(HeapObject* object,
                                                Address inner_pointer) {
  Code* code = reinterpret_cast<Code*>(object);
1664
  DCHECK(code != NULL && GcSafeCodeContains(code, inner_pointer));
1665
  return code;
1666 1667 1668
}


1669 1670
Code* InnerPointerToCodeCache::GcSafeFindCodeForInnerPointer(
    Address inner_pointer) {
1671
  Heap* heap = isolate_->heap();
1672

1673
  // Check if the inner pointer points into a large object chunk.
1674
  LargePage* large_page = heap->lo_space()->FindPage(inner_pointer);
1675 1676 1677
  if (large_page != NULL) {
    return GcSafeCastToCode(large_page->GetObject(), inner_pointer);
  }
1678

1679 1680 1681 1682
  if (!heap->code_space()->Contains(inner_pointer)) {
    return nullptr;
  }

1683
  // Iterate through the page until we reach the end or find an object starting
1684 1685
  // after the inner pointer.
  Page* page = Page::FromAddress(inner_pointer);
1686

1687
  DCHECK_EQ(page->owner(), heap->code_space());
mlippautz's avatar
mlippautz committed
1688 1689
  heap->mark_compact_collector()->sweeper().SweepOrWaitUntilSweepingCompleted(
      page);
1690

1691
  Address addr = page->skip_list()->StartFor(inner_pointer);
1692 1693 1694 1695

  Address top = heap->code_space()->top();
  Address limit = heap->code_space()->limit();

1696
  while (true) {
1697 1698 1699
    if (addr == top && addr != limit) {
      addr = limit;
      continue;
1700
    }
1701 1702 1703 1704

    HeapObject* obj = HeapObject::FromAddress(addr);
    int obj_size = GcSafeSizeOfCodeSpaceObject(obj);
    Address next_addr = addr + obj_size;
1705
    if (next_addr > inner_pointer) return GcSafeCastToCode(obj, inner_pointer);
1706
    addr = next_addr;
1707 1708 1709
  }
}

1710

1711 1712
InnerPointerToCodeCache::InnerPointerToCodeCacheEntry*
    InnerPointerToCodeCache::GetCacheEntry(Address inner_pointer) {
1713
  isolate_->counters()->pc_to_code()->Increment();
1714
  DCHECK(base::bits::IsPowerOfTwo32(kInnerPointerToCodeCacheSize));
1715 1716
  uint32_t hash = ComputeIntegerHash(ObjectAddressForHashing(inner_pointer),
                                     v8::internal::kZeroHashSeed);
1717 1718 1719
  uint32_t index = hash & (kInnerPointerToCodeCacheSize - 1);
  InnerPointerToCodeCacheEntry* entry = cache(index);
  if (entry->inner_pointer == inner_pointer) {
1720
    isolate_->counters()->pc_to_code_cached()->Increment();
1721
    DCHECK(entry->code == GcSafeFindCodeForInnerPointer(inner_pointer));
1722 1723
  } else {
    // Because this code may be interrupted by a profiling signal that
1724 1725
    // also queries the cache, we cannot update inner_pointer before the code
    // has been set. Otherwise, we risk trying to use a cache entry before
1726
    // the code has been computed.
1727
    entry->code = GcSafeFindCodeForInnerPointer(inner_pointer);
1728
    entry->safepoint_entry.Reset();
1729
    entry->inner_pointer = inner_pointer;
1730 1731 1732 1733 1734
  }
  return entry;
}


1735 1736 1737
// -------------------------------------------------------------------------


1738
int NumRegs(RegList reglist) { return base::bits::CountPopulation(reglist); }
1739 1740


1741 1742 1743 1744
struct JSCallerSavedCodeData {
  int reg_code[kNumJSCallerSaved];
};

1745
JSCallerSavedCodeData caller_saved_code_data;
1746

1747 1748 1749 1750 1751 1752
void SetUpJSCallerSavedCodeData() {
  int i = 0;
  for (int r = 0; r < kNumRegs; r++)
    if ((kJSCallerSaved & (1 << r)) != 0)
      caller_saved_code_data.reg_code[i++] = r;

1753
  DCHECK(i == kNumJSCallerSaved);
1754
}
1755

1756

1757
int JSCallerSavedCode(int n) {
1758
  DCHECK(0 <= n && n < kNumJSCallerSaved);
1759
  return caller_saved_code_data.reg_code[n];
1760 1761 1762
}


1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
#define DEFINE_WRAPPER(type, field)                              \
class field##_Wrapper : public ZoneObject {                      \
 public:  /* NOLINT */                                           \
  field##_Wrapper(const field& original) : frame_(original) {    \
  }                                                              \
  field frame_;                                                  \
};
STACK_FRAME_TYPE_LIST(DEFINE_WRAPPER)
#undef DEFINE_WRAPPER

1773
static StackFrame* AllocateFrameCopy(StackFrame* frame, Zone* zone) {
1774 1775 1776
#define FRAME_TYPE_CASE(type, field) \
  case StackFrame::type: { \
    field##_Wrapper* wrapper = \
1777
        new(zone) field##_Wrapper(*(reinterpret_cast<field*>(frame))); \
1778 1779 1780 1781 1782 1783 1784 1785 1786 1787 1788
    return &wrapper->frame_; \
  }

  switch (frame->type()) {
    STACK_FRAME_TYPE_LIST(FRAME_TYPE_CASE)
    default: UNREACHABLE();
  }
#undef FRAME_TYPE_CASE
  return NULL;
}

1789

1790
Vector<StackFrame*> CreateStackMap(Isolate* isolate, Zone* zone) {
1791
  ZoneList<StackFrame*> list(10, zone);
1792
  for (StackFrameIterator it(isolate); !it.done(); it.Advance()) {
1793 1794
    StackFrame* frame = AllocateFrameCopy(it.frame(), zone);
    list.Add(frame, zone);
1795 1796 1797 1798 1799
  }
  return list.ToVector();
}


1800 1801
}  // namespace internal
}  // namespace v8