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
143
144
145
146
147
148
149
150
151
152
153
154
155
156

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

#ifndef LLDB_SBThreadBinding_h_
#define LLDB_SBThreadBinding_h_

#include "lldb/Bindings/SBBindingDefines.h"

#ifdef __cplusplus
extern "C" {
#endif

LLDB_API const char *SBThreadGetBroadcasterClassName(void);

LLDB_API SBThreadRef CreateSBThread(void);

LLDB_API SBThreadRef CloneSBThread(SBThreadRef instance);

LLDB_API void DisposeSBThread(SBThreadRef instance);

LLDB_API SBQueueRef SBThreadGetQueue(SBThreadRef instance);

LLDB_API bool SBThreadIsValid(SBThreadRef instance);

LLDB_API void SBThreadClear(SBThreadRef instance);

LLDB_API ENUM(StopReason) SBThreadGetStopReason(SBThreadRef instance);

LLDB_API size_t SBThreadGetStopReasonDataCount(SBThreadRef instance);

LLDB_API uint64_t SBThreadGetStopReasonDataAtIndex(SBThreadRef instance,
                                                   uint32_t idx);

LLDB_API bool SBThreadGetStopReasonExtendedInfoAsJSON(SBThreadRef instance,
                                                      SBStreamRef stream);

LLDB_API SBThreadCollectionRef SBThreadGetStopReasonExtendedBacktaces(
    SBThreadRef instance, ENUM(InstrumentationRuntimeType) type);

LLDB_API size_t SBThreadGetStopDescription(SBThreadRef instance, char *dst,
                                           size_t dst_len);

LLDB_API SBValueRef SBThreadGetStopReturnValue(SBThreadRef instance);

LLDB_API lldb_tid_t SBThreadGetThreadID(SBThreadRef instance);

LLDB_API uint32_t SBThreadGetIndexID(SBThreadRef instance);

LLDB_API const char *SBThreadGetName(SBThreadRef instance);

LLDB_API const char *SBThreadGetQueueName(SBThreadRef instance);

LLDB_API lldb_queue_id_t SBThreadGetQueueID(SBThreadRef instance);

LLDB_API bool SBThreadGetInfoItemByPathAsString(SBThreadRef instance,
                                                const char *path,
                                                SBStreamRef strm);

LLDB_API void SBThreadStepOver(SBThreadRef instance,
                               ENUM(RunMode) stop_other_threads,
                               SBErrorRef error);

LLDB_API void SBThreadStepInto(SBThreadRef instance,
                               ENUM(RunMode) stop_other_threads);

LLDB_API void SBThreadStepInto2(SBThreadRef instance, const char *target_name,
                                ENUM(RunMode) stop_other_threads);

LLDB_API void SBThreadStepInto3(SBThreadRef instance, const char *target_name,
                                uint32_t end_line, SBErrorRef error,
                                ENUM(RunMode) stop_other_threads);

LLDB_API void SBThreadStepOut(SBThreadRef instance, SBErrorRef error);

LLDB_API void SBThreadStepOutOfFrame(SBThreadRef instance, SBFrameRef frame,
                                     SBErrorRef error);

LLDB_API void SBThreadStepInstruction(SBThreadRef instance, bool step_over,
                                      SBErrorRef error);

LLDB_API SBErrorRef SBThreadStepOverUntil(SBThreadRef instance,
                                          SBFrameRef frame,
                                          SBFileSpecRef file_spec,
                                          uint32_t line);

LLDB_API SBErrorRef SBThreadStepUsingScriptedThreadPlan(
    SBThreadRef instance, const char *script_class_name,
    SBStructuredDataRef args_data, bool resume_immediately);

LLDB_API SBErrorRef SBThreadJumpToLine(SBThreadRef instance,
                                       SBFileSpecRef file_spec, uint32_t line);

LLDB_API void SBThreadRunToAddress(SBThreadRef instance, lldb_addr_t addr,
                                   SBErrorRef error);

LLDB_API SBErrorRef SBThreadReturnFromFrame(SBThreadRef instance,
                                            SBFrameRef frame,
                                            SBValueRef return_value);

LLDB_API SBErrorRef SBThreadUnwindInnermostExpression(SBThreadRef instance);

LLDB_API bool SBThreadSuspend(SBThreadRef instance, SBErrorRef error);

LLDB_API bool SBThreadResume(SBThreadRef instance, SBErrorRef error);

LLDB_API bool SBThreadIsSuspended(SBThreadRef instance);

LLDB_API bool SBThreadIsStopped(SBThreadRef instance);

LLDB_API uint32_t SBThreadGetNumFrames(SBThreadRef instance);

LLDB_API SBFrameRef SBThreadGetFrameAtIndex(SBThreadRef instance, uint32_t idx);

LLDB_API SBFrameRef SBThreadGetSelectedFrame(SBThreadRef instance);

LLDB_API SBFrameRef SBThreadSetSelectedFrame(SBThreadRef instance,
                                             uint32_t frame_idx);

LLDB_API bool SBThreadEventIsThreadEvent(SBEventRef event);

LLDB_API SBFrameRef SBThreadGetStackFrameFromEvent(SBEventRef event);

LLDB_API SBThreadRef SBThreadGetThreadFromEvent(SBEventRef event);

LLDB_API SBProcessRef SBThreadGetProcess(SBThreadRef instance);

LLDB_API bool SBThreadGetDescription(SBThreadRef instance,
                                     SBStreamRef description);

LLDB_API bool SBThreadGetStatus(SBThreadRef instance, SBStreamRef status);

LLDB_API SBThreadRef SBThreadGetExtendedBacktraceThread(SBThreadRef instance,
                                                        const char *type);

LLDB_API uint32_t
SBThreadGetExtendedBacktraceOriginatingIndexID(SBThreadRef instance);

LLDB_API SBValueRef SBThreadGetCurrentException(SBThreadRef instance);

LLDB_API SBThreadRef SBThreadGetCurrentExceptionBacktrace(SBThreadRef instance);

LLDB_API bool SBThreadSafeToCallFunctions(SBThreadRef instance);

LLDB_API SBValueRef SBThreadGetSiginfo(SBThreadRef instance);

#ifdef __cplusplus
}
#endif

#endif // LLDB_SBThreadBinding_h_