breakpad 0.1.0

Basic breakpad/crashpad wrapper for Rust
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109

#include "google_breakpad/processor/stack_frame.h"
#include "processor/module_factory.h"

#include "cpp/data_definitions.h"
#include "cpp/resolver.h"

using google_breakpad::BasicModuleFactory;
using google_breakpad::StackFrame;

namespace {

// Factory for modules to resolve stack frames.
BasicModuleFactory factory;

// Defines the private nested type BasicSourceLineResolver::Module
using ResolverModule =
    typename std::remove_pointer<decltype(factory.CreateModule(""))>::type;

StackFrame *clone_stack_frame(const StackFrame *frame) {
  if (frame == nullptr) {
    return nullptr;
  }

  auto *clone = new StackFrame();
  if (clone == nullptr) {
    return nullptr;
  }

  // We only need to clone instructions that are not later overwritten by the
  // resolver. Therefore, we assume this is a pristine unresolved frame.
  clone->instruction = frame->instruction;
  clone->module = frame->module;
  clone->trust = frame->trust;

  return clone;
}

}  // namespace

typedef_extern_c(resolver_t, ResolverModule);

void stack_frame_delete(stack_frame_t *frame) {
  if (frame != nullptr) {
    delete stack_frame_t::cast(frame);
  }
}

const char *stack_frame_function_name(const stack_frame_t *frame) {
  if (frame == nullptr) {
    return nullptr;
  }

  return stack_frame_t::cast(frame)->function_name.c_str();
}

const char *stack_frame_source_file_name(const stack_frame_t *frame) {
  if (frame == nullptr) {
    return nullptr;
  }

  return stack_frame_t::cast(frame)->source_file_name.c_str();
}

int stack_frame_source_line(const stack_frame_t *frame) {
  if (frame == nullptr) {
    return 0;
  }

  return stack_frame_t::cast(frame)->source_line;
}

resolver_t *resolver_new(const char *symbol_buffer, size_t buffer_size) {
  if (symbol_buffer == nullptr || buffer_size == 0) {
    return nullptr;
  }

  auto *module = factory.CreateModule("");
  if (module == nullptr) {
    return nullptr;
  }

  module->LoadMapFromMemory(const_cast<char *>(symbol_buffer), buffer_size);
  return resolver_t::cast(module);
}

void resolver_delete(resolver_t *resolver) {
  if (resolver != nullptr) {
    delete resolver_t::cast(resolver);
  }
}

bool resolver_is_corrupt(const resolver_t *resolver) {
  return resolver_t::cast(resolver)->IsCorrupt();
}

stack_frame_t *resolver_resolve_frame(const resolver_t *resolver,
                                      const stack_frame_t *frame) {
  if (resolver == nullptr || frame == nullptr) {
    return nullptr;
  }

  auto *clone = clone_stack_frame(stack_frame_t::cast(frame));
  if (clone == nullptr) {
    return nullptr;
  }

  resolver_t::cast(resolver)->LookupAddress(clone);
  return stack_frame_t::cast(clone);
}