File Explorer

1// Copyright 2021 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4 5#ifndef INCLUDE_V8_UNWINDER_H_6#define INCLUDE_V8_UNWINDER_H_7 8#include <memory>9 10#include "v8-embedder-state-scope.h"  // NOLINT(build/include_directory)11#include "v8config.h"                 // NOLINT(build/include_directory)12 13namespace v8 {14// Holds the callee saved registers needed for the stack unwinder. It is the15// empty struct if no registers are required. Implemented in16// include/v8-unwinder-state.h.17struct CalleeSavedRegisters;18 19// A RegisterState represents the current state of registers used20// by the sampling profiler API.21struct V8_EXPORT RegisterState {22  RegisterState();23  ~RegisterState();24  RegisterState(const RegisterState& other);25  RegisterState& operator=(const RegisterState& other);26 27  void* pc;  // Instruction pointer.28  void* sp;  // Stack pointer.29  void* fp;  // Frame pointer.30  void* lr;  // Link register (or nullptr on platforms without a link register).31  // Callee saved registers (or null if no callee saved registers were stored)32  std::unique_ptr<CalleeSavedRegisters> callee_saved;33};34 35// A StateTag represents a possible state of the VM.36enum StateTag : uint16_t {37  JS,38  GC,39  PARSER,40  BYTECODE_COMPILER,41  COMPILER,42  OTHER,43  EXTERNAL,44  ATOMICS_WAIT,45  IDLE,46  LOGGING,47};48 49// The output structure filled up by GetStackSample API function.50struct SampleInfo {51  size_t frames_count;              // Number of frames collected.52  void* external_callback_entry;    // External callback address if VM is53                                    // executing an external callback.54  void* context;                    // Incumbent native context address.55  void* embedder_context;           // Native context address for embedder state56  StateTag vm_state;                // Current VM state.57  EmbedderStateTag embedder_state;  // Current Embedder state58};59 60struct MemoryRange {61  const void* start = nullptr;62  size_t length_in_bytes = 0;63};64 65struct JSEntryStub {66  MemoryRange code;67};68 69struct JSEntryStubs {70  JSEntryStub js_entry_stub;71  JSEntryStub js_construct_entry_stub;72  JSEntryStub js_run_microtasks_entry_stub;73};74 75/**76 * Various helpers for skipping over V8 frames in a given stack.77 *78 * The unwinder API is only supported on the x64, ARM64 and ARM32 architectures.79 */80class V8_EXPORT Unwinder {81 public:82  /**83   * Attempt to unwind the stack to the most recent C++ frame. This function is84   * signal-safe and does not access any V8 state and thus doesn't require an85   * Isolate.86   *87   * The unwinder needs to know the location of the JS Entry Stub (a piece of88   * code that is run when C++ code calls into generated JS code). This is used89   * for edge cases where the current frame is being constructed or torn down90   * when the stack sample occurs.91   *92   * The unwinder also needs the virtual memory range of all possible V8 code93   * objects. There are two ranges required - the heap code range and the range94   * for code embedded in the binary.95   *96   * Available on x64, ARM64 and ARM32.97   *98   * \param code_pages A list of all of the ranges in which V8 has allocated99   * executable code. The caller should obtain this list by calling100   * Isolate::CopyCodePages() during the same interrupt/thread suspension that101   * captures the stack.102   * \param register_state The current registers. This is an in-out param that103   * will be overwritten with the register values after unwinding, on success.104   * \param stack_base The resulting stack pointer and frame pointer values are105   * bounds-checked against the stack_base and the original stack pointer value106   * to ensure that they are valid locations in the given stack. If these values107   * or any intermediate frame pointer values used during unwinding are ever out108   * of these bounds, unwinding will fail.109   *110   * \return True on success.111   */112  static bool TryUnwindV8Frames(const JSEntryStubs& entry_stubs,113                                size_t code_pages_length,114                                const MemoryRange* code_pages,115                                RegisterState* register_state,116                                const void* stack_base);117 118  /**119   * Whether the PC is within the V8 code range represented by code_pages.120   *121   * If this returns false, then calling UnwindV8Frames() with the same PC122   * and unwind_state will always fail. If it returns true, then unwinding may123   * (but not necessarily) be successful.124   *125   * Available on x64, ARM64 and ARM32126   */127  static bool PCIsInV8(size_t code_pages_length, const MemoryRange* code_pages,128                       void* pc);129};130 131}  // namespace v8132 133#endif  // INCLUDE_V8_UNWINDER_H_134