lldb-sys 0.0.31

Raw bindings to the LLDB C++ API. LLDB is the debugger that is part of the LLVM project and is the default system debugger on Mac OS X. Building and using this is currently slightly tricky, so be sure to see the README.md in the repository.
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
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

//===-- SBAddressBinding.cpp ------------------------------------*- C++ -*-===//
//
//                     The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//

#include "lldb/API/LLDB.h"
#include "lldb/Bindings/LLDBBinding.h"

using namespace lldb;

#ifdef __cplusplus
extern "C" {
#endif

SBAddressRef CreateSBAddress() {
  return reinterpret_cast<SBAddressRef>(new SBAddress());
}

SBAddressRef CreateSBAddress2(SBSectionRef section, lldb_addr_t offset) {
  return reinterpret_cast<SBAddressRef>(
      new SBAddress(*reinterpret_cast<SBSection *>(section), offset));
}

SBAddressRef CreateSBAddress3(lldb_addr_t load_addr, SBTargetRef target) {
  return reinterpret_cast<SBAddressRef>(
      new SBAddress(load_addr, *reinterpret_cast<SBTarget *>(target)));
}

SBAddressRef CloneSBAddress(SBAddressRef instance) {
  return reinterpret_cast<SBAddressRef>(
      new SBAddress(*reinterpret_cast<SBAddress *>(instance)));
}

void DisposeSBAddress(SBAddressRef instance) {
  delete reinterpret_cast<SBAddress *>(instance);
}

bool SBAddressIsValid(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->IsValid();
}

void SBAddressClear(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  unwrapped->Clear();
}

lldb_addr_t SBAddressGetFileAddress(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->GetFileAddress();
}

lldb_addr_t SBAddressGetLoadAddress(SBAddressRef instance, SBTargetRef target) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->GetLoadAddress(*reinterpret_cast<SBTarget *>(target));
}

void SBAddressSetAddress(SBAddressRef instance, SBSectionRef section,
                         lldb_addr_t offset) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  unwrapped->SetAddress(*reinterpret_cast<SBSection *>(section), offset);
}

void SBAddressSetLoadAddress(SBAddressRef instance, lldb_addr_t load_addr,
                             SBTargetRef target) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  unwrapped->SetLoadAddress(load_addr, *reinterpret_cast<SBTarget *>(target));
}

bool SBAddressOffsetAddress(SBAddressRef instance, lldb_addr_t offset) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->OffsetAddress(offset);
}

bool SBAddressGetDescription(SBAddressRef instance, SBStreamRef description) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->GetDescription(*reinterpret_cast<SBStream *>(description));
}

SBSymbolContextRef SBAddressGetSymbolContext(SBAddressRef instance,
                                             uint32_t resolve_scope) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBSymbolContextRef>(
      new SBSymbolContext(unwrapped->GetSymbolContext(resolve_scope)));
}

SBSectionRef SBAddressGetSection(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBSectionRef>(new SBSection(unwrapped->GetSection()));
}

lldb_addr_t SBAddressGetOffset(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return unwrapped->GetOffset();
}

SBModuleRef SBAddressGetModule(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBModuleRef>(new SBModule(unwrapped->GetModule()));
}

SBCompileUnitRef SBAddressGetCompileUnit(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBCompileUnitRef>(
      new SBCompileUnit(unwrapped->GetCompileUnit()));
}

SBFunctionRef SBAddressGetFunction(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBFunctionRef>(
      new SBFunction(unwrapped->GetFunction()));
}

SBBlockRef SBAddressGetBlock(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBBlockRef>(new SBBlock(unwrapped->GetBlock()));
}

SBSymbolRef SBAddressGetSymbol(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBSymbolRef>(new SBSymbol(unwrapped->GetSymbol()));
}

SBLineEntryRef SBAddressGetLineEntry(SBAddressRef instance) {
  SBAddress *unwrapped = reinterpret_cast<SBAddress *>(instance);
  return reinterpret_cast<SBLineEntryRef>(
      new SBLineEntry(unwrapped->GetLineEntry()));
}

bool SBAddressIsEqual(SBAddressRef instance, SBAddressRef other) {
  SBAddress *instance_unwrapped = reinterpret_cast<SBAddress *>(instance);
  SBAddress *other_unwrapped = reinterpret_cast<SBAddress *>(other);
  return *instance_unwrapped == *other_unwrapped;
}

#ifdef __cplusplus
}
#endif