unwinding-info-win64.h

Go to the documentation of this file.

// Copyright 2019 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
 
#ifndef V8_DIAGNOSTICS_UNWINDING_INFO_WIN64_H_
#define V8_DIAGNOSTICS_UNWINDING_INFO_WIN64_H_
 
#include <vector>
 
#include "include/v8-callbacks.h"
#include "include/v8config.h"
#include "src/common/globals.h"
 
#if defined(V8_OS_WIN64)
#include "src/base/win32-headers.h"
 
namespace v8 {
namespace internal {
 
namespace win64_unwindinfo {
 
#define CRASH_HANDLER_FUNCTION_NAME CrashForExceptionInNonABICompliantCodeRange
#define CRASH_HANDLER_FUNCTION_NAME_STRING \
  "CrashForExceptionInNonABICompliantCodeRange"
 
static const int kOSPageSize = 4096;
 
bool CanEmitUnwindInfoForBuiltins();
 
bool CanRegisterUnwindInfoForNonABICompliantCodeRange();
 
void SetUnhandledExceptionCallback(
    v8::UnhandledExceptionCallback unhandled_exception_callback);
 
void RegisterNonABICompliantCodeRange(void* start, size_t size_in_bytes);
void UnregisterNonABICompliantCodeRange(void* start);
 
static const uint32_t kDefaultRuntimeFunctionCount = 1;
 
#if defined(V8_OS_WIN_X64)
 
static const int kPushRbpInstructionLength = 1;
static const int kMovRbpRspInstructionLength = 3;
static const int kRbpPrefixCodes = 2;
static const int kRbpPrefixLength =
    kPushRbpInstructionLength + kMovRbpRspInstructionLength;
 
std::vector<uint8_t> GetUnwindInfoForBuiltinFunctions();
 
class BuiltinUnwindInfo {
 public:
  BuiltinUnwindInfo() : is_leaf_function_(true) {}
  explicit BuiltinUnwindInfo(const std::vector<int>& fp_offsets)
      : is_leaf_function_(false), fp_offsets_(fp_offsets) {}
 
  bool is_leaf_function() const { return is_leaf_function_; }
  const std::vector<int>& fp_offsets() const { return fp_offsets_; }
 
 private:
  bool is_leaf_function_;
  std::vector<int> fp_offsets_;
};
 
class XdataEncoder {
 public:
  explicit XdataEncoder(const Assembler& assembler)
      : assembler_(assembler), current_frame_code_offset_(-1) {}
 
  void onPushRbp();
  void onMovRbpRsp();
 
  BuiltinUnwindInfo unwinding_info() const {
    return BuiltinUnwindInfo(fp_offsets_);
  }
 
 private:
  const Assembler& assembler_;
  std::vector<int> fp_offsets_;
  int current_frame_code_offset_;
};
 
#elif defined(V8_OS_WIN_ARM64)
 
static const int kMaxFunctionLength = ((1 << 18) - 1) << 2;
 
struct FrameOffsets {
  FrameOffsets();
  bool IsDefault() const;
  int fp_to_saved_caller_fp;
  int fp_to_caller_sp;
};
 
std::vector<uint8_t> GetUnwindInfoForBuiltinFunction(
    uint32_t func_len, FrameOffsets fp_adjustment);
class BuiltinUnwindInfo {
 public:
  BuiltinUnwindInfo() : is_leaf_function_(true) {}
  explicit BuiltinUnwindInfo(const std::vector<int>& fp_offsets,
                             const std::vector<FrameOffsets>& fp_adjustments)
      : is_leaf_function_(false),
        fp_offsets_(fp_offsets),
        fp_adjustments_(fp_adjustments) {}
 
  const std::vector<FrameOffsets>& fp_adjustments() const {
    return fp_adjustments_;
  }
 
  bool is_leaf_function() const { return is_leaf_function_; }
  const std::vector<int>& fp_offsets() const { return fp_offsets_; }
 
 private:
  bool is_leaf_function_;
  std::vector<int> fp_offsets_;
  std::vector<FrameOffsets> fp_adjustments_;
};
 
class XdataEncoder {
 public:
  explicit XdataEncoder(const Assembler& assembler)
      : assembler_(assembler), current_frame_code_offset_(-1) {}
 
  void onSaveFpLr();
  void onFramePointerAdjustment(int fp_to_saved_caller_fp, int fp_to_caller_sp);
 
  BuiltinUnwindInfo unwinding_info() const {
    return BuiltinUnwindInfo(fp_offsets_, fp_adjustments_);
  }
 
 private:
  const Assembler& assembler_;
  std::vector<int> fp_offsets_;
  int current_frame_code_offset_;
  FrameOffsets current_frame_adjustment_;
  std::vector<FrameOffsets> fp_adjustments_;
};
 
#endif
 
}  // namespace win64_unwindinfo
}  // namespace internal
}  // namespace v8
 
#endif  // V8_OS_WIN64
 
#endif  // V8_DIAGNOSTICS_UNWINDING_INFO_WIN64_H_