aboutsummaryrefslogtreecommitdiff
path: root/lldb/include/lldb/API/SBThreadPlan.h
blob: 0dc48437a6681b9c08d2e7da5a17c6b73ec19702 (plain) (blame)
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
//===-- SBThreadPlan.h ------------------------------------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#ifndef LLDB_API_SBTHREADPLAN_H
#define LLDB_API_SBTHREADPLAN_H

#include "lldb/API/SBDefines.h"

#include <stdio.h>

namespace lldb {

class LLDB_API SBThreadPlan {

  friend class lldb_private::ThreadPlan;

public:
  SBThreadPlan();

  SBThreadPlan(const lldb::SBThreadPlan &threadPlan);

  SBThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);

  SBThreadPlan(lldb::SBThread &thread, const char *class_name);

  SBThreadPlan(lldb::SBThread &thread, const char *class_name, 
               lldb::SBStructuredData &args_data);

  ~SBThreadPlan();

  explicit operator bool() const;

  bool IsValid() const;

  void Clear();

  lldb::StopReason GetStopReason();

  /// Get the number of words associated with the stop reason.
  /// See also GetStopReasonDataAtIndex().
  size_t GetStopReasonDataCount();

  /// Get information associated with a stop reason.
  ///
  /// Breakpoint stop reasons will have data that consists of pairs of
  /// breakpoint IDs followed by the breakpoint location IDs (they always come
  /// in pairs).
  ///
  /// Stop Reason              Count Data Type
  /// ======================== ===== =========================================
  /// eStopReasonNone          0
  /// eStopReasonTrace         0
  /// eStopReasonBreakpoint    N     duple: {breakpoint id, location id}
  /// eStopReasonWatchpoint    1     watchpoint id
  /// eStopReasonSignal        1     unix signal number
  /// eStopReasonException     N     exception data
  /// eStopReasonExec          0
  /// eStopReasonPlanComplete  0
  uint64_t GetStopReasonDataAtIndex(uint32_t idx);

  SBThread GetThread() const;

  const lldb::SBThreadPlan &operator=(const lldb::SBThreadPlan &rhs);

  bool GetDescription(lldb::SBStream &description) const;

  void SetPlanComplete(bool success);

  bool IsPlanComplete();

  bool IsPlanStale();

  bool IsValid();

  bool GetStopOthers();

  void SetStopOthers(bool stop_others);

  // This section allows an SBThreadPlan to push another of the common types of
  // plans...
  SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
                                               lldb::addr_t range_size);
  SBThreadPlan QueueThreadPlanForStepOverRange(SBAddress &start_address,
                                               lldb::addr_t range_size,
                                               SBError &error);

  SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
                                             lldb::addr_t range_size);
  SBThreadPlan QueueThreadPlanForStepInRange(SBAddress &start_address,
                                             lldb::addr_t range_size,
                                             SBError &error);

  SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn = false);
  SBThreadPlan QueueThreadPlanForStepOut(uint32_t frame_idx_to_step_to,
                                         bool first_insn, SBError &error);

  SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address);
  SBThreadPlan QueueThreadPlanForRunToAddress(SBAddress address,
                                              SBError &error);

  SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name);
  SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                              SBError &error);
  SBThreadPlan QueueThreadPlanForStepScripted(const char *script_class_name,
                                              lldb::SBStructuredData &args_data,
                                              SBError &error);

private:
  friend class SBBreakpoint;
  friend class SBBreakpointLocation;
  friend class SBFrame;
  friend class SBProcess;
  friend class SBDebugger;
  friend class SBValue;
  friend class lldb_private::QueueImpl;
  friend class SBQueueItem;

  lldb::ThreadPlanSP GetSP() const { return m_opaque_wp.lock(); }
  lldb_private::ThreadPlan *get() const { return GetSP().get(); }
  void SetThreadPlan(const lldb::ThreadPlanSP &lldb_object_sp);

  lldb::ThreadPlanWP m_opaque_wp;
};

} // namespace lldb

#endif // LLDB_API_SBTHREADPLAN_H