Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- SBDebugger.cpp ------------------------------------------*- C++ -*-===// |
| 2 | // |
| 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
| 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
| 7 | // |
| 8 | //===----------------------------------------------------------------------===// |
| 9 | |
Eli Friedman | d6ec8aa | 2010-06-09 07:37:52 +0000 | [diff] [blame] | 10 | #include "lldb/API/SBDebugger.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 11 | |
| 12 | #include "lldb/lldb-include.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 13 | |
Eli Friedman | d6ec8aa | 2010-06-09 07:37:52 +0000 | [diff] [blame] | 14 | #include "lldb/API/SBListener.h" |
| 15 | #include "lldb/API/SBBroadcaster.h" |
| 16 | #include "lldb/API/SBCommandInterpreter.h" |
| 17 | #include "lldb/API/SBCommandReturnObject.h" |
| 18 | #include "lldb/API/SBEvent.h" |
| 19 | #include "lldb/API/SBFrame.h" |
Eli Friedman | d6ec8aa | 2010-06-09 07:37:52 +0000 | [diff] [blame] | 20 | #include "lldb/API/SBInputReader.h" |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 21 | #include "lldb/API/SBProcess.h" |
| 22 | #include "lldb/API/SBSourceManager.h" |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 23 | #include "lldb/API/SBStream.h" |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 24 | #include "lldb/API/SBStringList.h" |
| 25 | #include "lldb/API/SBTarget.h" |
| 26 | #include "lldb/API/SBThread.h" |
Greg Clayton | 887aa28 | 2010-10-11 01:05:37 +0000 | [diff] [blame] | 27 | #include "lldb/Core/Debugger.h" |
| 28 | #include "lldb/Core/State.h" |
| 29 | #include "lldb/Interpreter/Args.h" |
| 30 | #include "lldb/Interpreter/CommandInterpreter.h" |
| 31 | #include "lldb/Target/Process.h" |
| 32 | #include "lldb/Target/TargetList.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 33 | |
| 34 | using namespace lldb; |
| 35 | using namespace lldb_private; |
| 36 | |
| 37 | void |
| 38 | SBDebugger::Initialize () |
| 39 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 40 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 41 | |
| 42 | if (log) |
| 43 | log->Printf ("SBDebugger::Initialize ()"); |
| 44 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 45 | Debugger::Initialize(); |
| 46 | } |
| 47 | |
| 48 | void |
| 49 | SBDebugger::Terminate () |
| 50 | { |
| 51 | Debugger::Terminate(); |
| 52 | } |
| 53 | |
Greg Clayton | 43490d1 | 2010-07-30 20:12:55 +0000 | [diff] [blame] | 54 | void |
| 55 | SBDebugger::Clear () |
| 56 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 57 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 58 | |
| 59 | if (log) |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 60 | log->Printf ("SBDebugger(%p)::Clear ()", m_opaque_sp.get()); |
Caroline Tice | c044686 | 2010-12-20 18:35:50 +0000 | [diff] [blame] | 61 | |
| 62 | if (m_opaque_sp) |
| 63 | m_opaque_sp->CleanUpInputReaders (); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 64 | |
Greg Clayton | 43490d1 | 2010-07-30 20:12:55 +0000 | [diff] [blame] | 65 | m_opaque_sp.reset(); |
| 66 | } |
| 67 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 68 | SBDebugger |
| 69 | SBDebugger::Create() |
| 70 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 71 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 72 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 73 | SBDebugger debugger; |
| 74 | debugger.reset(Debugger::CreateInstance()); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 75 | |
| 76 | if (log) |
| 77 | { |
| 78 | SBStream sstr; |
| 79 | debugger.GetDescription (sstr); |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 80 | log->Printf ("SBDebugger::Create () => SBDebugger(%p): %s", debugger.m_opaque_sp.get(), sstr.GetData()); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 81 | } |
| 82 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 83 | return debugger; |
| 84 | } |
| 85 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 86 | SBDebugger::SBDebugger () : |
| 87 | m_opaque_sp () |
| 88 | { |
| 89 | } |
| 90 | |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 91 | SBDebugger::SBDebugger(const SBDebugger &rhs) : |
| 92 | m_opaque_sp (rhs.m_opaque_sp) |
| 93 | { |
| 94 | } |
| 95 | |
| 96 | SBDebugger & |
| 97 | SBDebugger::operator = (const SBDebugger &rhs) |
| 98 | { |
| 99 | if (this != &rhs) |
| 100 | { |
| 101 | m_opaque_sp = rhs.m_opaque_sp; |
| 102 | } |
| 103 | return *this; |
| 104 | } |
| 105 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 106 | SBDebugger::~SBDebugger () |
| 107 | { |
| 108 | } |
| 109 | |
| 110 | bool |
| 111 | SBDebugger::IsValid() const |
| 112 | { |
| 113 | return m_opaque_sp.get() != NULL; |
| 114 | } |
| 115 | |
| 116 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 117 | void |
| 118 | SBDebugger::SetAsync (bool b) |
| 119 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 120 | if (m_opaque_sp) |
| 121 | m_opaque_sp->SetAsyncExecution(b); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 122 | } |
| 123 | |
Greg Clayton | 887aa28 | 2010-10-11 01:05:37 +0000 | [diff] [blame] | 124 | void |
| 125 | SBDebugger::SkipLLDBInitFiles (bool b) |
| 126 | { |
| 127 | if (m_opaque_sp) |
| 128 | m_opaque_sp->GetCommandInterpreter().SkipLLDBInitFiles (b); |
| 129 | } |
| 130 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 131 | // Shouldn't really be settable after initialization as this could cause lots of problems; don't want users |
| 132 | // trying to switch modes in the middle of a debugging session. |
| 133 | void |
| 134 | SBDebugger::SetInputFileHandle (FILE *fh, bool transfer_ownership) |
| 135 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 136 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 137 | |
| 138 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 139 | log->Printf ("SBDebugger(%p)::SetInputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), |
| 140 | fh, transfer_ownership); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 141 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 142 | if (m_opaque_sp) |
| 143 | m_opaque_sp->SetInputFileHandle (fh, transfer_ownership); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 144 | } |
| 145 | |
| 146 | void |
| 147 | SBDebugger::SetOutputFileHandle (FILE *fh, bool transfer_ownership) |
| 148 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 149 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 150 | |
| 151 | |
| 152 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 153 | log->Printf ("SBDebugger(%p)::SetOutputFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), |
| 154 | fh, transfer_ownership); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 155 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 156 | if (m_opaque_sp) |
| 157 | m_opaque_sp->SetOutputFileHandle (fh, transfer_ownership); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 158 | } |
| 159 | |
| 160 | void |
| 161 | SBDebugger::SetErrorFileHandle (FILE *fh, bool transfer_ownership) |
| 162 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 163 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 164 | |
| 165 | |
| 166 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 167 | log->Printf ("SBDebugger(%p)::SetErrorFileHandle (fh=%p, transfer_ownership=%i)", m_opaque_sp.get(), |
| 168 | fh, transfer_ownership); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 169 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 170 | if (m_opaque_sp) |
| 171 | m_opaque_sp->SetErrorFileHandle (fh, transfer_ownership); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 172 | } |
| 173 | |
| 174 | FILE * |
| 175 | SBDebugger::GetInputFileHandle () |
| 176 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 177 | if (m_opaque_sp) |
| 178 | return m_opaque_sp->GetInputFileHandle(); |
| 179 | return NULL; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 180 | } |
| 181 | |
| 182 | FILE * |
| 183 | SBDebugger::GetOutputFileHandle () |
| 184 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 185 | if (m_opaque_sp) |
| 186 | return m_opaque_sp->GetOutputFileHandle(); |
| 187 | return NULL; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 188 | } |
| 189 | |
| 190 | FILE * |
| 191 | SBDebugger::GetErrorFileHandle () |
| 192 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 193 | if (m_opaque_sp) |
| 194 | return m_opaque_sp->GetErrorFileHandle(); |
| 195 | return NULL; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | SBCommandInterpreter |
| 199 | SBDebugger::GetCommandInterpreter () |
| 200 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 201 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 202 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 203 | SBCommandInterpreter sb_interpreter; |
| 204 | if (m_opaque_sp) |
| 205 | sb_interpreter.reset (&m_opaque_sp->GetCommandInterpreter()); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 206 | |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 207 | if (log) |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 208 | log->Printf ("SBDebugger(%p)::GetCommandInterpreter () => SBCommandInterpreter(%p)", |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 209 | m_opaque_sp.get(), sb_interpreter.get()); |
| 210 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 211 | return sb_interpreter; |
| 212 | } |
| 213 | |
| 214 | void |
| 215 | SBDebugger::HandleCommand (const char *command) |
| 216 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 217 | if (m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 218 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 219 | TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); |
| 220 | Mutex::Locker api_locker; |
| 221 | if (target_sp) |
| 222 | api_locker.Reset(target_sp->GetAPIMutex().GetMutex()); |
| 223 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 224 | SBCommandInterpreter sb_interpreter(GetCommandInterpreter ()); |
| 225 | SBCommandReturnObject result; |
| 226 | |
| 227 | sb_interpreter.HandleCommand (command, result, false); |
| 228 | |
| 229 | if (GetErrorFileHandle() != NULL) |
| 230 | result.PutError (GetErrorFileHandle()); |
| 231 | if (GetOutputFileHandle() != NULL) |
| 232 | result.PutOutput (GetOutputFileHandle()); |
| 233 | |
| 234 | if (m_opaque_sp->GetAsyncExecution() == false) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 235 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 236 | SBProcess process(GetCommandInterpreter().GetProcess ()); |
| 237 | if (process.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 238 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 239 | EventSP event_sp; |
| 240 | Listener &lldb_listener = m_opaque_sp->GetListener(); |
| 241 | while (lldb_listener.GetNextEventForBroadcaster (process.get(), event_sp)) |
| 242 | { |
| 243 | SBEvent event(event_sp); |
| 244 | HandleProcessEvent (process, event, GetOutputFileHandle(), GetErrorFileHandle()); |
| 245 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 246 | } |
| 247 | } |
| 248 | } |
| 249 | } |
| 250 | |
| 251 | SBListener |
| 252 | SBDebugger::GetListener () |
| 253 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 254 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 255 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 256 | SBListener sb_listener; |
| 257 | if (m_opaque_sp) |
| 258 | sb_listener.reset(&m_opaque_sp->GetListener(), false); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 259 | |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 260 | if (log) |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 261 | log->Printf ("SBDebugger(%p)::GetListener () => SBListener(%p)", m_opaque_sp.get(), |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 262 | sb_listener.get()); |
| 263 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 264 | return sb_listener; |
| 265 | } |
| 266 | |
| 267 | void |
| 268 | SBDebugger::HandleProcessEvent (const SBProcess &process, const SBEvent &event, FILE *out, FILE *err) |
| 269 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 270 | if (!process.IsValid()) |
| 271 | return; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 272 | |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 273 | const uint32_t event_type = event.GetType(); |
| 274 | char stdio_buffer[1024]; |
| 275 | size_t len; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 276 | |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 277 | Mutex::Locker api_locker (process.GetTarget()->GetAPIMutex()); |
| 278 | |
| 279 | if (event_type & (Process::eBroadcastBitSTDOUT | Process::eBroadcastBitStateChanged)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 280 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 281 | // Drain stdout when we stop just in case we have any bytes |
| 282 | while ((len = process.GetSTDOUT (stdio_buffer, sizeof (stdio_buffer))) > 0) |
| 283 | if (out != NULL) |
| 284 | ::fwrite (stdio_buffer, 1, len, out); |
| 285 | } |
| 286 | |
| 287 | if (event_type & (Process::eBroadcastBitSTDERR | Process::eBroadcastBitStateChanged)) |
| 288 | { |
| 289 | // Drain stderr when we stop just in case we have any bytes |
| 290 | while ((len = process.GetSTDERR (stdio_buffer, sizeof (stdio_buffer))) > 0) |
| 291 | if (err != NULL) |
| 292 | ::fwrite (stdio_buffer, 1, len, err); |
| 293 | } |
| 294 | |
| 295 | if (event_type & Process::eBroadcastBitStateChanged) |
| 296 | { |
| 297 | StateType event_state = SBProcess::GetStateFromEvent (event); |
| 298 | |
| 299 | if (event_state == eStateInvalid) |
| 300 | return; |
| 301 | |
| 302 | bool is_stopped = StateIsStoppedState (event_state); |
| 303 | if (!is_stopped) |
| 304 | process.ReportEventState (event, out); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 305 | } |
| 306 | } |
| 307 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 308 | SBSourceManager & |
| 309 | SBDebugger::GetSourceManager () |
| 310 | { |
| 311 | static SourceManager g_lldb_source_manager; |
Greg Clayton | 538eb82 | 2010-11-05 23:17:00 +0000 | [diff] [blame] | 312 | static SBSourceManager g_sb_source_manager (&g_lldb_source_manager); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 313 | return g_sb_source_manager; |
| 314 | } |
| 315 | |
| 316 | |
| 317 | bool |
| 318 | SBDebugger::GetDefaultArchitecture (char *arch_name, size_t arch_name_len) |
| 319 | { |
| 320 | if (arch_name && arch_name_len) |
| 321 | { |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 322 | ArchSpec default_arch = lldb_private::Target::GetDefaultArchitecture (); |
| 323 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 324 | if (default_arch.IsValid()) |
| 325 | { |
| 326 | ::snprintf (arch_name, arch_name_len, "%s", default_arch.AsCString()); |
| 327 | return true; |
| 328 | } |
| 329 | } |
| 330 | if (arch_name && arch_name_len) |
| 331 | arch_name[0] = '\0'; |
| 332 | return false; |
| 333 | } |
| 334 | |
| 335 | |
| 336 | bool |
| 337 | SBDebugger::SetDefaultArchitecture (const char *arch_name) |
| 338 | { |
| 339 | if (arch_name) |
| 340 | { |
| 341 | ArchSpec arch (arch_name); |
| 342 | if (arch.IsValid()) |
| 343 | { |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 344 | lldb_private::Target::SetDefaultArchitecture (arch); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 345 | return true; |
| 346 | } |
| 347 | } |
| 348 | return false; |
| 349 | } |
| 350 | |
| 351 | ScriptLanguage |
| 352 | SBDebugger::GetScriptingLanguage (const char *script_language_name) |
| 353 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 354 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 355 | return Args::StringToScriptLanguage (script_language_name, |
| 356 | eScriptLanguageDefault, |
| 357 | NULL); |
| 358 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 359 | |
| 360 | const char * |
| 361 | SBDebugger::GetVersionString () |
| 362 | { |
| 363 | return lldb_private::GetVersion(); |
| 364 | } |
| 365 | |
| 366 | const char * |
| 367 | SBDebugger::StateAsCString (lldb::StateType state) |
| 368 | { |
| 369 | return lldb_private::StateAsCString (state); |
| 370 | } |
| 371 | |
| 372 | bool |
| 373 | SBDebugger::StateIsRunningState (lldb::StateType state) |
| 374 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 375 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 376 | |
| 377 | const bool result = lldb_private::StateIsRunningState (state); |
| 378 | if (log) |
| 379 | log->Printf ("SBDebugger::StateIsRunningState (state=%s) => %i", |
| 380 | lldb_private::StateAsCString (state), result); |
| 381 | |
| 382 | return result; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 383 | } |
| 384 | |
| 385 | bool |
| 386 | SBDebugger::StateIsStoppedState (lldb::StateType state) |
| 387 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 388 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 389 | |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 390 | const bool result = lldb_private::StateIsStoppedState (state); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 391 | if (log) |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 392 | log->Printf ("SBDebugger::StateIsStoppedState (state=%s) => %i", |
| 393 | lldb_private::StateAsCString (state), result); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 394 | |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 395 | return result; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 396 | } |
| 397 | |
| 398 | |
| 399 | SBTarget |
| 400 | SBDebugger::CreateTargetWithFileAndTargetTriple (const char *filename, |
| 401 | const char *target_triple) |
| 402 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 403 | SBTarget target; |
| 404 | if (m_opaque_sp) |
| 405 | { |
| 406 | ArchSpec arch; |
Greg Clayton | 537a7a8 | 2010-10-20 20:54:39 +0000 | [diff] [blame] | 407 | FileSpec file_spec (filename, true); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 408 | arch.SetArchFromTargetTriple(target_triple); |
| 409 | TargetSP target_sp; |
| 410 | Error error (m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file_spec, arch, NULL, true, target_sp)); |
| 411 | target.reset (target_sp); |
| 412 | } |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 413 | |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 414 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 415 | if (log) |
| 416 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 417 | log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndTargetTriple (filename=\"%s\", triple=%s) => SBTarget(%p)", |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 418 | m_opaque_sp.get(), filename, target_triple, target.get()); |
| 419 | } |
| 420 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 421 | return target; |
| 422 | } |
| 423 | |
| 424 | SBTarget |
| 425 | SBDebugger::CreateTargetWithFileAndArch (const char *filename, const char *archname) |
| 426 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 427 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 428 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 429 | SBTarget target; |
| 430 | if (m_opaque_sp) |
| 431 | { |
Greg Clayton | 537a7a8 | 2010-10-20 20:54:39 +0000 | [diff] [blame] | 432 | FileSpec file (filename, true); |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 433 | ArchSpec arch = lldb_private::Target::GetDefaultArchitecture (); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 434 | TargetSP target_sp; |
| 435 | Error error; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 436 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 437 | if (archname != NULL) |
| 438 | { |
| 439 | ArchSpec arch2 (archname); |
| 440 | error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch2, NULL, true, target_sp); |
| 441 | } |
| 442 | else |
| 443 | { |
| 444 | if (!arch.IsValid()) |
| 445 | arch = LLDB_ARCH_DEFAULT; |
| 446 | |
| 447 | error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp); |
| 448 | |
| 449 | if (error.Fail()) |
| 450 | { |
| 451 | if (arch == LLDB_ARCH_DEFAULT_32BIT) |
| 452 | arch = LLDB_ARCH_DEFAULT_64BIT; |
| 453 | else |
| 454 | arch = LLDB_ARCH_DEFAULT_32BIT; |
| 455 | |
| 456 | error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp); |
| 457 | } |
| 458 | } |
| 459 | |
| 460 | if (error.Success()) |
| 461 | { |
Jim Ingham | c833295 | 2010-08-26 21:32:51 +0000 | [diff] [blame] | 462 | m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 463 | target.reset(target_sp); |
| 464 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 465 | } |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 466 | |
| 467 | if (log) |
| 468 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 469 | log->Printf ("SBDebugger(%p)::CreateTargetWithFileAndArch (filename=\"%s\", arch=%s) => SBTarget(%p)", |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 470 | m_opaque_sp.get(), filename, archname, target.get()); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 471 | } |
| 472 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 473 | return target; |
| 474 | } |
| 475 | |
| 476 | SBTarget |
| 477 | SBDebugger::CreateTarget (const char *filename) |
| 478 | { |
| 479 | SBTarget target; |
| 480 | if (m_opaque_sp) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 481 | { |
Greg Clayton | 537a7a8 | 2010-10-20 20:54:39 +0000 | [diff] [blame] | 482 | FileSpec file (filename, true); |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 483 | ArchSpec arch = lldb_private::Target::GetDefaultArchitecture (); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 484 | TargetSP target_sp; |
| 485 | Error error; |
| 486 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 487 | if (!arch.IsValid()) |
| 488 | arch = LLDB_ARCH_DEFAULT; |
| 489 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 490 | error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 491 | |
| 492 | if (error.Fail()) |
| 493 | { |
| 494 | if (arch == LLDB_ARCH_DEFAULT_32BIT) |
| 495 | arch = LLDB_ARCH_DEFAULT_64BIT; |
| 496 | else |
| 497 | arch = LLDB_ARCH_DEFAULT_32BIT; |
| 498 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 499 | error = m_opaque_sp->GetTargetList().CreateTarget (*m_opaque_sp, file, arch, NULL, true, target_sp); |
| 500 | } |
| 501 | |
| 502 | if (error.Success()) |
| 503 | { |
Jim Ingham | c833295 | 2010-08-26 21:32:51 +0000 | [diff] [blame] | 504 | m_opaque_sp->GetTargetList().SetSelectedTarget (target_sp.get()); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 505 | target.reset (target_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 506 | } |
| 507 | } |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 508 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 509 | if (log) |
| 510 | { |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 511 | log->Printf ("SBDebugger(%p)::CreateTarget (filename=\"%s\") => SBTarget(%p)", |
Greg Clayton | a66ba46 | 2010-10-30 04:51:46 +0000 | [diff] [blame] | 512 | m_opaque_sp.get(), filename, target.get()); |
| 513 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 514 | return target; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 515 | } |
| 516 | |
| 517 | SBTarget |
| 518 | SBDebugger::GetTargetAtIndex (uint32_t idx) |
| 519 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 520 | SBTarget sb_target; |
| 521 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 522 | { |
| 523 | // No need to lock, the target list is thread safe |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 524 | sb_target.reset(m_opaque_sp->GetTargetList().GetTargetAtIndex (idx)); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 525 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 526 | return sb_target; |
| 527 | } |
| 528 | |
| 529 | SBTarget |
| 530 | SBDebugger::FindTargetWithProcessID (pid_t pid) |
| 531 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 532 | SBTarget sb_target; |
| 533 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 534 | { |
| 535 | // No need to lock, the target list is thread safe |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 536 | sb_target.reset(m_opaque_sp->GetTargetList().FindTargetWithProcessID (pid)); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 537 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 538 | return sb_target; |
| 539 | } |
| 540 | |
| 541 | SBTarget |
| 542 | SBDebugger::FindTargetWithFileAndArch (const char *filename, const char *arch_name) |
| 543 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 544 | SBTarget sb_target; |
| 545 | if (m_opaque_sp && filename && filename[0]) |
| 546 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 547 | // No need to lock, the target list is thread safe |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 548 | ArchSpec arch; |
| 549 | if (arch_name) |
| 550 | arch.SetArch(arch_name); |
Greg Clayton | 537a7a8 | 2010-10-20 20:54:39 +0000 | [diff] [blame] | 551 | TargetSP target_sp (m_opaque_sp->GetTargetList().FindTargetWithExecutableAndArchitecture (FileSpec(filename, false), arch_name ? &arch : NULL)); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 552 | sb_target.reset(target_sp); |
| 553 | } |
| 554 | return sb_target; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 555 | } |
| 556 | |
| 557 | SBTarget |
| 558 | SBDebugger::FindTargetWithLLDBProcess (const lldb::ProcessSP &process_sp) |
| 559 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 560 | SBTarget sb_target; |
| 561 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 562 | { |
| 563 | // No need to lock, the target list is thread safe |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 564 | sb_target.reset(m_opaque_sp->GetTargetList().FindTargetWithProcess (process_sp.get())); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 565 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 566 | return sb_target; |
| 567 | } |
| 568 | |
| 569 | |
| 570 | uint32_t |
| 571 | SBDebugger::GetNumTargets () |
| 572 | { |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 573 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 574 | { |
| 575 | // No need to lock, the target list is thread safe |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 576 | return m_opaque_sp->GetTargetList().GetNumTargets (); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 577 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 578 | return 0; |
| 579 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 580 | |
| 581 | SBTarget |
Jim Ingham | c833295 | 2010-08-26 21:32:51 +0000 | [diff] [blame] | 582 | SBDebugger::GetSelectedTarget () |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 583 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 584 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 585 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 586 | SBTarget sb_target; |
| 587 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 588 | { |
| 589 | // No need to lock, the target list is thread safe |
Jim Ingham | c833295 | 2010-08-26 21:32:51 +0000 | [diff] [blame] | 590 | sb_target.reset(m_opaque_sp->GetTargetList().GetSelectedTarget ()); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 591 | } |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 592 | |
| 593 | if (log) |
| 594 | { |
| 595 | SBStream sstr; |
| 596 | sb_target.GetDescription (sstr, lldb::eDescriptionLevelBrief); |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 597 | log->Printf ("SBDebugger(%p)::GetSelectedTarget () => SBTarget(%p): %s", m_opaque_sp.get(), |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 598 | sb_target.get(), sstr.GetData()); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 599 | } |
| 600 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 601 | return sb_target; |
| 602 | } |
| 603 | |
| 604 | void |
| 605 | SBDebugger::DispatchInput (void *baton, const void *data, size_t data_len) |
| 606 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 607 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 608 | |
| 609 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 610 | log->Printf ("SBDebugger(%p)::DispatchInput (baton=%p, data=\"%.*s\", size_t=%zu)", m_opaque_sp.get(), |
| 611 | baton, (int) data_len, (const char *) data, data_len); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 612 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 613 | if (m_opaque_sp) |
| 614 | m_opaque_sp->DispatchInput ((const char *) data, data_len); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 615 | } |
| 616 | |
| 617 | void |
Caroline Tice | c4f55fe | 2010-11-19 20:47:54 +0000 | [diff] [blame] | 618 | SBDebugger::DispatchInputInterrupt () |
| 619 | { |
| 620 | if (m_opaque_sp) |
| 621 | m_opaque_sp->DispatchInputInterrupt (); |
| 622 | } |
| 623 | |
| 624 | void |
| 625 | SBDebugger::DispatchInputEndOfFile () |
| 626 | { |
| 627 | if (m_opaque_sp) |
| 628 | m_opaque_sp->DispatchInputEndOfFile (); |
| 629 | } |
| 630 | |
| 631 | void |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 632 | SBDebugger::PushInputReader (SBInputReader &reader) |
| 633 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 634 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 635 | |
| 636 | if (log) |
Greg Clayton | 3f5ee7f | 2010-10-29 04:59:35 +0000 | [diff] [blame] | 637 | log->Printf ("SBDebugger(%p)::PushInputReader (SBInputReader(%p))", m_opaque_sp.get(), &reader); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 638 | |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 639 | if (m_opaque_sp && reader.IsValid()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 640 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 641 | TargetSP target_sp (m_opaque_sp->GetSelectedTarget()); |
| 642 | Mutex::Locker api_locker; |
| 643 | if (target_sp) |
| 644 | api_locker.Reset(target_sp->GetAPIMutex().GetMutex()); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 645 | InputReaderSP reader_sp(*reader); |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 646 | m_opaque_sp->PushInputReader (reader_sp); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 647 | } |
| 648 | } |
Greg Clayton | 63094e0 | 2010-06-23 01:19:29 +0000 | [diff] [blame] | 649 | |
| 650 | void |
| 651 | SBDebugger::reset (const lldb::DebuggerSP &debugger_sp) |
| 652 | { |
| 653 | m_opaque_sp = debugger_sp; |
| 654 | } |
| 655 | |
| 656 | Debugger * |
| 657 | SBDebugger::get () const |
| 658 | { |
| 659 | return m_opaque_sp.get(); |
| 660 | } |
| 661 | |
| 662 | Debugger & |
| 663 | SBDebugger::ref () const |
| 664 | { |
| 665 | assert (m_opaque_sp.get()); |
| 666 | return *m_opaque_sp; |
| 667 | } |
| 668 | |
| 669 | |
Caroline Tice | 558be58 | 2010-06-30 16:22:25 +0000 | [diff] [blame] | 670 | SBDebugger |
| 671 | SBDebugger::FindDebuggerWithID (int id) |
| 672 | { |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 673 | // No need to lock, the debugger list is thread safe |
Caroline Tice | 558be58 | 2010-06-30 16:22:25 +0000 | [diff] [blame] | 674 | SBDebugger sb_debugger; |
| 675 | lldb::DebuggerSP debugger_sp = Debugger::FindDebuggerWithID (id); |
| 676 | if (debugger_sp) |
| 677 | sb_debugger.reset (debugger_sp); |
| 678 | return sb_debugger; |
| 679 | } |
Jim Ingham | 74989e8 | 2010-08-30 19:44:40 +0000 | [diff] [blame] | 680 | |
Caroline Tice | b8314fe | 2010-09-09 17:45:09 +0000 | [diff] [blame] | 681 | const char * |
| 682 | SBDebugger::GetInstanceName() |
| 683 | { |
| 684 | if (m_opaque_sp) |
| 685 | return m_opaque_sp->GetInstanceName().AsCString(); |
| 686 | else |
| 687 | return NULL; |
| 688 | } |
| 689 | |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 690 | SBError |
Caroline Tice | b8314fe | 2010-09-09 17:45:09 +0000 | [diff] [blame] | 691 | SBDebugger::SetInternalVariable (const char *var_name, const char *value, const char *debugger_instance_name) |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 692 | { |
| 693 | lldb::UserSettingsControllerSP root_settings_controller = lldb_private::Debugger::GetSettingsController(); |
Caroline Tice | 1d2aefd | 2010-09-09 06:25:08 +0000 | [diff] [blame] | 694 | |
Caroline Tice | 1ebef44 | 2010-09-27 00:30:10 +0000 | [diff] [blame] | 695 | Error err = root_settings_controller->SetVariable (var_name, value, lldb::eVarSetOperationAssign, true, |
Caroline Tice | 1d2aefd | 2010-09-09 06:25:08 +0000 | [diff] [blame] | 696 | debugger_instance_name); |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 697 | SBError sb_error; |
| 698 | sb_error.SetError (err); |
| 699 | |
| 700 | return sb_error; |
| 701 | } |
| 702 | |
| 703 | lldb::SBStringList |
Caroline Tice | b8314fe | 2010-09-09 17:45:09 +0000 | [diff] [blame] | 704 | SBDebugger::GetInternalVariableValue (const char *var_name, const char *debugger_instance_name) |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 705 | { |
| 706 | SBStringList ret_value; |
Caroline Tice | 1d2aefd | 2010-09-09 06:25:08 +0000 | [diff] [blame] | 707 | lldb::SettableVariableType var_type; |
Johnny Chen | f5e4326 | 2010-12-20 20:33:26 +0000 | [diff] [blame] | 708 | lldb_private::Error err; |
Caroline Tice | 1d2aefd | 2010-09-09 06:25:08 +0000 | [diff] [blame] | 709 | |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 710 | lldb::UserSettingsControllerSP root_settings_controller = lldb_private::Debugger::GetSettingsController(); |
| 711 | |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 712 | StringList value = root_settings_controller->GetVariable (var_name, var_type, debugger_instance_name, err); |
| 713 | |
| 714 | if (err.Success()) |
| 715 | { |
| 716 | for (unsigned i = 0; i != value.GetSize(); ++i) |
| 717 | ret_value.AppendString (value.GetStringAtIndex(i)); |
| 718 | } |
| 719 | else |
| 720 | { |
| 721 | ret_value.AppendString (err.AsCString()); |
| 722 | } |
| 723 | |
Caroline Tice | 6e4c5ce | 2010-09-04 00:03:46 +0000 | [diff] [blame] | 724 | |
| 725 | return ret_value; |
| 726 | } |
| 727 | |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 728 | uint32_t |
| 729 | SBDebugger::GetTerminalWidth () const |
| 730 | { |
| 731 | if (m_opaque_sp) |
| 732 | return m_opaque_sp->GetTerminalWidth (); |
| 733 | return 0; |
| 734 | } |
| 735 | |
| 736 | void |
| 737 | SBDebugger::SetTerminalWidth (uint32_t term_width) |
| 738 | { |
| 739 | if (m_opaque_sp) |
| 740 | m_opaque_sp->SetTerminalWidth (term_width); |
| 741 | } |
| 742 | |
| 743 | const char * |
| 744 | SBDebugger::GetPrompt() const |
| 745 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 746 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 747 | |
| 748 | if (log) |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 749 | log->Printf ("SBDebugger(%p)::GetPrompt () => \"%s\"", m_opaque_sp.get(), |
Caroline Tice | 61ba7ec | 2010-10-26 23:49:36 +0000 | [diff] [blame] | 750 | (m_opaque_sp ? m_opaque_sp->GetPrompt() : "")); |
Caroline Tice | 7826c88 | 2010-10-26 03:11:13 +0000 | [diff] [blame] | 751 | |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 752 | if (m_opaque_sp) |
| 753 | return m_opaque_sp->GetPrompt (); |
| 754 | return 0; |
| 755 | } |
| 756 | |
| 757 | void |
| 758 | SBDebugger::SetPrompt (const char *prompt) |
| 759 | { |
| 760 | if (m_opaque_sp) |
| 761 | m_opaque_sp->SetPrompt (prompt); |
| 762 | } |
| 763 | |
| 764 | |
| 765 | lldb::ScriptLanguage |
| 766 | SBDebugger::GetScriptLanguage() const |
| 767 | { |
| 768 | if (m_opaque_sp) |
| 769 | return m_opaque_sp->GetScriptLanguage (); |
| 770 | return eScriptLanguageNone; |
| 771 | } |
| 772 | |
| 773 | void |
| 774 | SBDebugger::SetScriptLanguage (lldb::ScriptLanguage script_lang) |
| 775 | { |
| 776 | if (m_opaque_sp) |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 777 | { |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 778 | m_opaque_sp->SetScriptLanguage (script_lang); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 779 | } |
Greg Clayton | 238c0a1 | 2010-09-18 01:14:36 +0000 | [diff] [blame] | 780 | } |
| 781 | |
Jim Ingham | 74989e8 | 2010-08-30 19:44:40 +0000 | [diff] [blame] | 782 | bool |
| 783 | SBDebugger::SetUseExternalEditor (bool value) |
| 784 | { |
| 785 | if (m_opaque_sp) |
| 786 | return m_opaque_sp->SetUseExternalEditor (value); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 787 | return false; |
Jim Ingham | 74989e8 | 2010-08-30 19:44:40 +0000 | [diff] [blame] | 788 | } |
| 789 | |
| 790 | bool |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 791 | SBDebugger::GetUseExternalEditor () |
Jim Ingham | 74989e8 | 2010-08-30 19:44:40 +0000 | [diff] [blame] | 792 | { |
| 793 | if (m_opaque_sp) |
Caroline Tice | 5bc8c97 | 2010-09-20 20:44:43 +0000 | [diff] [blame] | 794 | return m_opaque_sp->GetUseExternalEditor (); |
Greg Clayton | bdcda46 | 2010-12-20 20:49:23 +0000 | [diff] [blame] | 795 | return false; |
Jim Ingham | 74989e8 | 2010-08-30 19:44:40 +0000 | [diff] [blame] | 796 | } |
| 797 | |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 798 | bool |
| 799 | SBDebugger::GetDescription (SBStream &description) |
| 800 | { |
| 801 | if (m_opaque_sp) |
| 802 | { |
| 803 | const char *name = m_opaque_sp->GetInstanceName().AsCString(); |
| 804 | lldb::user_id_t id = m_opaque_sp->GetID(); |
Greg Clayton | 49ce682 | 2010-10-31 03:01:06 +0000 | [diff] [blame] | 805 | description.Printf ("Debugger (instance: \"%s\", id: %d)", name, id); |
Caroline Tice | 98f930f | 2010-09-20 05:20:02 +0000 | [diff] [blame] | 806 | } |
| 807 | else |
| 808 | description.Printf ("No value"); |
| 809 | |
| 810 | return true; |
| 811 | } |
Caroline Tice | c4f55fe | 2010-11-19 20:47:54 +0000 | [diff] [blame] | 812 | |
| 813 | lldb::user_id_t |
| 814 | SBDebugger::GetID() |
| 815 | { |
| 816 | if (m_opaque_sp) |
| 817 | return m_opaque_sp->GetID(); |
| 818 | return LLDB_INVALID_UID; |
| 819 | } |