1 //===-- Debugger.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
10 #include "lldb/Core/Debugger.h"
11
12 #include <map>
13
14 #include "clang/AST/DeclCXX.h"
15 #include "clang/AST/Type.h"
16 #include "llvm/ADT/StringRef.h"
17
18 #include "lldb/lldb-private.h"
19 #include "lldb/Core/FormatEntity.h"
20 #include "lldb/Core/Module.h"
21 #include "lldb/Core/PluginManager.h"
22 #include "lldb/Core/RegisterValue.h"
23 #include "lldb/Core/State.h"
24 #include "lldb/Core/StreamAsynchronousIO.h"
25 #include "lldb/Core/StreamCallback.h"
26 #include "lldb/Core/StreamFile.h"
27 #include "lldb/Core/StreamString.h"
28 #include "lldb/Core/StructuredData.h"
29 #include "lldb/Core/Timer.h"
30 #include "lldb/Core/ValueObject.h"
31 #include "lldb/Core/ValueObjectVariable.h"
32 #include "lldb/DataFormatters/DataVisualization.h"
33 #include "lldb/DataFormatters/FormatManager.h"
34 #include "lldb/DataFormatters/TypeSummary.h"
35 #include "lldb/Host/ConnectionFileDescriptor.h"
36 #include "lldb/Host/HostInfo.h"
37 #include "lldb/Host/Terminal.h"
38 #include "lldb/Host/ThreadLauncher.h"
39 #include "lldb/Interpreter/CommandInterpreter.h"
40 #include "lldb/Interpreter/OptionValueProperties.h"
41 #include "lldb/Interpreter/OptionValueSInt64.h"
42 #include "lldb/Interpreter/OptionValueString.h"
43 #include "lldb/Symbol/ClangASTContext.h"
44 #include "lldb/Symbol/CompileUnit.h"
45 #include "lldb/Symbol/Function.h"
46 #include "lldb/Symbol/Symbol.h"
47 #include "lldb/Symbol/VariableList.h"
48 #include "lldb/Target/CPPLanguageRuntime.h"
49 #include "lldb/Target/ObjCLanguageRuntime.h"
50 #include "lldb/Target/TargetList.h"
51 #include "lldb/Target/Process.h"
52 #include "lldb/Target/RegisterContext.h"
53 #include "lldb/Target/SectionLoadList.h"
54 #include "lldb/Target/StopInfo.h"
55 #include "lldb/Target/Target.h"
56 #include "lldb/Target/Thread.h"
57 #include "lldb/Utility/AnsiTerminal.h"
58
59 #include "llvm/Support/DynamicLibrary.h"
60
61 using namespace lldb;
62 using namespace lldb_private;
63
64
65 static lldb::user_id_t g_unique_id = 1;
66 static size_t g_debugger_event_thread_stack_bytes = 8 * 1024 * 1024;
67
68 #pragma mark Static Functions
69
70 static Mutex &
GetDebuggerListMutex()71 GetDebuggerListMutex ()
72 {
73 static Mutex g_mutex(Mutex::eMutexTypeRecursive);
74 return g_mutex;
75 }
76
77 typedef std::vector<DebuggerSP> DebuggerList;
78
79 static DebuggerList &
GetDebuggerList()80 GetDebuggerList()
81 {
82 // hide the static debugger list inside a singleton accessor to avoid
83 // global init constructors
84 static DebuggerList g_list;
85 return g_list;
86 }
87
88 OptionEnumValueElement
89 g_show_disassembly_enum_values[] =
90 {
91 { Debugger::eStopDisassemblyTypeNever, "never", "Never show disassembly when displaying a stop context."},
92 { Debugger::eStopDisassemblyTypeNoSource, "no-source", "Show disassembly when there is no source information, or the source file is missing when displaying a stop context."},
93 { Debugger::eStopDisassemblyTypeAlways, "always", "Always show disassembly when displaying a stop context."},
94 { 0, NULL, NULL }
95 };
96
97 OptionEnumValueElement
98 g_language_enumerators[] =
99 {
100 { eScriptLanguageNone, "none", "Disable scripting languages."},
101 { eScriptLanguagePython, "python", "Select python as the default scripting language."},
102 { eScriptLanguageDefault, "default", "Select the lldb default as the default scripting language."},
103 { 0, NULL, NULL }
104 };
105
106 #define MODULE_WITH_FUNC "{ ${module.file.basename}{`${function.name-with-args}${function.pc-offset}}}"
107 #define FILE_AND_LINE "{ at ${line.file.basename}:${line.number}}"
108
109 #define DEFAULT_THREAD_FORMAT "thread #${thread.index}: tid = ${thread.id%tid}"\
110 "{, ${frame.pc}}"\
111 MODULE_WITH_FUNC\
112 FILE_AND_LINE\
113 "{, name = '${thread.name}'}"\
114 "{, queue = '${thread.queue}'}"\
115 "{, activity = '${thread.info.activity.name}'}" \
116 "{, ${thread.info.trace_messages} messages}" \
117 "{, stop reason = ${thread.stop-reason}}"\
118 "{\\nReturn value: ${thread.return-value}}"\
119 "{\\nCompleted expression: ${thread.completed-expression}}"\
120 "\\n"
121
122 #define DEFAULT_FRAME_FORMAT "frame #${frame.index}: ${frame.pc}"\
123 MODULE_WITH_FUNC\
124 FILE_AND_LINE\
125 "\\n"
126
127 // Three parts to this disassembly format specification:
128 // 1. If this is a new function/symbol (no previous symbol/function), print
129 // dylib`funcname:\n
130 // 2. If this is a symbol context change (different from previous symbol/function), print
131 // dylib`funcname:\n
132 // 3. print
133 // address <+offset>:
134 #define DEFAULT_DISASSEMBLY_FORMAT "{${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }${addr-file-or-load}{ <${function.concrete-only-addr-offset-no-padding}>}: "
135
136 // gdb's disassembly format can be emulated with
137 // ${current-pc-arrow}${addr-file-or-load}{ <${function.name-without-args}${function.concrete-only-addr-offset-no-padding}>}:
138
139 // lldb's original format for disassembly would look like this format string -
140 // {${function.initial-function}{${module.file.basename}`}{${function.name-without-args}}:\n}{${function.changed}\n{${module.file.basename}`}{${function.name-without-args}}:\n}{${current-pc-arrow} }{${addr-file-or-load}}:
141
142
143 static PropertyDefinition
144 g_properties[] =
145 {
146 { "auto-confirm", OptionValue::eTypeBoolean , true, false, NULL, NULL, "If true all confirmation prompts will receive their default reply." },
147 { "disassembly-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_DISASSEMBLY_FORMAT, NULL, "The default disassembly format string to use when disassembling instruction sequences." },
148 { "frame-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_FRAME_FORMAT, NULL, "The default frame format string to use when displaying stack frame information for threads." },
149 { "notify-void", OptionValue::eTypeBoolean , true, false, NULL, NULL, "Notify the user explicitly if an expression returns void (default: false)." },
150 { "prompt", OptionValue::eTypeString , true, OptionValueString::eOptionEncodeCharacterEscapeSequences, "(lldb) ", NULL, "The debugger command line prompt displayed for the user." },
151 { "script-lang", OptionValue::eTypeEnum , true, eScriptLanguagePython, NULL, g_language_enumerators, "The script language to be used for evaluating user-written scripts." },
152 { "stop-disassembly-count", OptionValue::eTypeSInt64 , true, 4 , NULL, NULL, "The number of disassembly lines to show when displaying a stopped context." },
153 { "stop-disassembly-display", OptionValue::eTypeEnum , true, Debugger::eStopDisassemblyTypeNoSource, NULL, g_show_disassembly_enum_values, "Control when to display disassembly when displaying a stopped context." },
154 { "stop-line-count-after", OptionValue::eTypeSInt64 , true, 3 , NULL, NULL, "The number of sources lines to display that come after the current source line when displaying a stopped context." },
155 { "stop-line-count-before", OptionValue::eTypeSInt64 , true, 3 , NULL, NULL, "The number of sources lines to display that come before the current source line when displaying a stopped context." },
156 { "term-width", OptionValue::eTypeSInt64 , true, 80 , NULL, NULL, "The maximum number of columns to use for displaying text." },
157 { "thread-format", OptionValue::eTypeFormatEntity, true, 0 , DEFAULT_THREAD_FORMAT, NULL, "The default thread format string to use when displaying thread information." },
158 { "use-external-editor", OptionValue::eTypeBoolean , true, false, NULL, NULL, "Whether to use an external editor or not." },
159 { "use-color", OptionValue::eTypeBoolean , true, true , NULL, NULL, "Whether to use Ansi color codes or not." },
160 { "auto-one-line-summaries", OptionValue::eTypeBoolean , true, true, NULL, NULL, "If true, LLDB will automatically display small structs in one-liner format (default: true)." },
161 { "escape-non-printables", OptionValue::eTypeBoolean , true, true, NULL, NULL, "If true, LLDB will automatically escape non-printable and escape characters when formatting strings." },
162 { NULL, OptionValue::eTypeInvalid , true, 0 , NULL, NULL, NULL }
163 };
164
165 enum
166 {
167 ePropertyAutoConfirm = 0,
168 ePropertyDisassemblyFormat,
169 ePropertyFrameFormat,
170 ePropertyNotiftVoid,
171 ePropertyPrompt,
172 ePropertyScriptLanguage,
173 ePropertyStopDisassemblyCount,
174 ePropertyStopDisassemblyDisplay,
175 ePropertyStopLineCountAfter,
176 ePropertyStopLineCountBefore,
177 ePropertyTerminalWidth,
178 ePropertyThreadFormat,
179 ePropertyUseExternalEditor,
180 ePropertyUseColor,
181 ePropertyAutoOneLineSummaries,
182 ePropertyEscapeNonPrintables
183 };
184
185 LoadPluginCallbackType Debugger::g_load_plugin_callback = NULL;
186
187 Error
SetPropertyValue(const ExecutionContext * exe_ctx,VarSetOperationType op,const char * property_path,const char * value)188 Debugger::SetPropertyValue (const ExecutionContext *exe_ctx,
189 VarSetOperationType op,
190 const char *property_path,
191 const char *value)
192 {
193 bool is_load_script = strcmp(property_path,"target.load-script-from-symbol-file") == 0;
194 bool is_escape_non_printables = strcmp(property_path, "escape-non-printables") == 0;
195 TargetSP target_sp;
196 LoadScriptFromSymFile load_script_old_value;
197 if (is_load_script && exe_ctx->GetTargetSP())
198 {
199 target_sp = exe_ctx->GetTargetSP();
200 load_script_old_value = target_sp->TargetProperties::GetLoadScriptFromSymbolFile();
201 }
202 Error error (Properties::SetPropertyValue (exe_ctx, op, property_path, value));
203 if (error.Success())
204 {
205 // FIXME it would be nice to have "on-change" callbacks for properties
206 if (strcmp(property_path, g_properties[ePropertyPrompt].name) == 0)
207 {
208 const char *new_prompt = GetPrompt();
209 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor());
210 if (str.length())
211 new_prompt = str.c_str();
212 GetCommandInterpreter().UpdatePrompt(new_prompt);
213 EventSP prompt_change_event_sp (new Event(CommandInterpreter::eBroadcastBitResetPrompt, new EventDataBytes (new_prompt)));
214 GetCommandInterpreter().BroadcastEvent (prompt_change_event_sp);
215 }
216 else if (strcmp(property_path, g_properties[ePropertyUseColor].name) == 0)
217 {
218 // use-color changed. Ping the prompt so it can reset the ansi terminal codes.
219 SetPrompt (GetPrompt());
220 }
221 else if (is_load_script && target_sp && load_script_old_value == eLoadScriptFromSymFileWarn)
222 {
223 if (target_sp->TargetProperties::GetLoadScriptFromSymbolFile() == eLoadScriptFromSymFileTrue)
224 {
225 std::list<Error> errors;
226 StreamString feedback_stream;
227 if (!target_sp->LoadScriptingResources(errors,&feedback_stream))
228 {
229 StreamFileSP stream_sp (GetErrorFile());
230 if (stream_sp)
231 {
232 for (auto error : errors)
233 {
234 stream_sp->Printf("%s\n",error.AsCString());
235 }
236 if (feedback_stream.GetSize())
237 stream_sp->Printf("%s",feedback_stream.GetData());
238 }
239 }
240 }
241 }
242 else if (is_escape_non_printables)
243 {
244 DataVisualization::ForceUpdate();
245 }
246 }
247 return error;
248 }
249
250 bool
GetAutoConfirm() const251 Debugger::GetAutoConfirm () const
252 {
253 const uint32_t idx = ePropertyAutoConfirm;
254 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
255 }
256
257 const FormatEntity::Entry *
GetDisassemblyFormat() const258 Debugger::GetDisassemblyFormat() const
259 {
260 const uint32_t idx = ePropertyDisassemblyFormat;
261 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
262 }
263
264 const FormatEntity::Entry *
GetFrameFormat() const265 Debugger::GetFrameFormat() const
266 {
267 const uint32_t idx = ePropertyFrameFormat;
268 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
269 }
270
271 bool
GetNotifyVoid() const272 Debugger::GetNotifyVoid () const
273 {
274 const uint32_t idx = ePropertyNotiftVoid;
275 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
276 }
277
278 const char *
GetPrompt() const279 Debugger::GetPrompt() const
280 {
281 const uint32_t idx = ePropertyPrompt;
282 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, g_properties[idx].default_cstr_value);
283 }
284
285 void
SetPrompt(const char * p)286 Debugger::SetPrompt(const char *p)
287 {
288 const uint32_t idx = ePropertyPrompt;
289 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
290 const char *new_prompt = GetPrompt();
291 std::string str = lldb_utility::ansi::FormatAnsiTerminalCodes (new_prompt, GetUseColor());
292 if (str.length())
293 new_prompt = str.c_str();
294 GetCommandInterpreter().UpdatePrompt(new_prompt);
295 }
296
297 const FormatEntity::Entry *
GetThreadFormat() const298 Debugger::GetThreadFormat() const
299 {
300 const uint32_t idx = ePropertyThreadFormat;
301 return m_collection_sp->GetPropertyAtIndexAsFormatEntity(NULL, idx);
302 }
303
304 lldb::ScriptLanguage
GetScriptLanguage() const305 Debugger::GetScriptLanguage() const
306 {
307 const uint32_t idx = ePropertyScriptLanguage;
308 return (lldb::ScriptLanguage)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
309 }
310
311 bool
SetScriptLanguage(lldb::ScriptLanguage script_lang)312 Debugger::SetScriptLanguage (lldb::ScriptLanguage script_lang)
313 {
314 const uint32_t idx = ePropertyScriptLanguage;
315 return m_collection_sp->SetPropertyAtIndexAsEnumeration (NULL, idx, script_lang);
316 }
317
318 uint32_t
GetTerminalWidth() const319 Debugger::GetTerminalWidth () const
320 {
321 const uint32_t idx = ePropertyTerminalWidth;
322 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
323 }
324
325 bool
SetTerminalWidth(uint32_t term_width)326 Debugger::SetTerminalWidth (uint32_t term_width)
327 {
328 const uint32_t idx = ePropertyTerminalWidth;
329 return m_collection_sp->SetPropertyAtIndexAsSInt64 (NULL, idx, term_width);
330 }
331
332 bool
GetUseExternalEditor() const333 Debugger::GetUseExternalEditor () const
334 {
335 const uint32_t idx = ePropertyUseExternalEditor;
336 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
337 }
338
339 bool
SetUseExternalEditor(bool b)340 Debugger::SetUseExternalEditor (bool b)
341 {
342 const uint32_t idx = ePropertyUseExternalEditor;
343 return m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
344 }
345
346 bool
GetUseColor() const347 Debugger::GetUseColor () const
348 {
349 const uint32_t idx = ePropertyUseColor;
350 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
351 }
352
353 bool
SetUseColor(bool b)354 Debugger::SetUseColor (bool b)
355 {
356 const uint32_t idx = ePropertyUseColor;
357 bool ret = m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
358 SetPrompt (GetPrompt());
359 return ret;
360 }
361
362 uint32_t
GetStopSourceLineCount(bool before) const363 Debugger::GetStopSourceLineCount (bool before) const
364 {
365 const uint32_t idx = before ? ePropertyStopLineCountBefore : ePropertyStopLineCountAfter;
366 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
367 }
368
369 Debugger::StopDisassemblyType
GetStopDisassemblyDisplay() const370 Debugger::GetStopDisassemblyDisplay () const
371 {
372 const uint32_t idx = ePropertyStopDisassemblyDisplay;
373 return (Debugger::StopDisassemblyType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
374 }
375
376 uint32_t
GetDisassemblyLineCount() const377 Debugger::GetDisassemblyLineCount () const
378 {
379 const uint32_t idx = ePropertyStopDisassemblyCount;
380 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
381 }
382
383 bool
GetAutoOneLineSummaries() const384 Debugger::GetAutoOneLineSummaries () const
385 {
386 const uint32_t idx = ePropertyAutoOneLineSummaries;
387 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
388 }
389
390 bool
GetEscapeNonPrintables() const391 Debugger::GetEscapeNonPrintables () const
392 {
393 const uint32_t idx = ePropertyEscapeNonPrintables;
394 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, true);
395 }
396
397 #pragma mark Debugger
398
399 //const DebuggerPropertiesSP &
400 //Debugger::GetSettings() const
401 //{
402 // return m_properties_sp;
403 //}
404 //
405
406 static bool lldb_initialized = false;
407 void
Initialize(LoadPluginCallbackType load_plugin_callback)408 Debugger::Initialize(LoadPluginCallbackType load_plugin_callback)
409 {
410 assert(!lldb_initialized && "Debugger::Initialize called more than once!");
411
412 lldb_initialized = true;
413 g_load_plugin_callback = load_plugin_callback;
414 }
415
416 void
Terminate()417 Debugger::Terminate ()
418 {
419 assert(lldb_initialized && "Debugger::Terminate called without a matching Debugger::Initialize!");
420
421 // Clear our master list of debugger objects
422 Mutex::Locker locker (GetDebuggerListMutex ());
423 GetDebuggerList().clear();
424 }
425
426 void
SettingsInitialize()427 Debugger::SettingsInitialize ()
428 {
429 Target::SettingsInitialize ();
430 }
431
432 void
SettingsTerminate()433 Debugger::SettingsTerminate ()
434 {
435 Target::SettingsTerminate ();
436 }
437
438 bool
LoadPlugin(const FileSpec & spec,Error & error)439 Debugger::LoadPlugin (const FileSpec& spec, Error& error)
440 {
441 if (g_load_plugin_callback)
442 {
443 llvm::sys::DynamicLibrary dynlib = g_load_plugin_callback (shared_from_this(), spec, error);
444 if (dynlib.isValid())
445 {
446 m_loaded_plugins.push_back(dynlib);
447 return true;
448 }
449 }
450 else
451 {
452 // The g_load_plugin_callback is registered in SBDebugger::Initialize()
453 // and if the public API layer isn't available (code is linking against
454 // all of the internal LLDB static libraries), then we can't load plugins
455 error.SetErrorString("Public API layer is not available");
456 }
457 return false;
458 }
459
460 static FileSpec::EnumerateDirectoryResult
LoadPluginCallback(void * baton,FileSpec::FileType file_type,const FileSpec & file_spec)461 LoadPluginCallback
462 (
463 void *baton,
464 FileSpec::FileType file_type,
465 const FileSpec &file_spec
466 )
467 {
468 Error error;
469
470 static ConstString g_dylibext("dylib");
471 static ConstString g_solibext("so");
472
473 if (!baton)
474 return FileSpec::eEnumerateDirectoryResultQuit;
475
476 Debugger *debugger = (Debugger*)baton;
477
478 // If we have a regular file, a symbolic link or unknown file type, try
479 // and process the file. We must handle unknown as sometimes the directory
480 // enumeration might be enumerating a file system that doesn't have correct
481 // file type information.
482 if (file_type == FileSpec::eFileTypeRegular ||
483 file_type == FileSpec::eFileTypeSymbolicLink ||
484 file_type == FileSpec::eFileTypeUnknown )
485 {
486 FileSpec plugin_file_spec (file_spec);
487 plugin_file_spec.ResolvePath ();
488
489 if (plugin_file_spec.GetFileNameExtension() != g_dylibext &&
490 plugin_file_spec.GetFileNameExtension() != g_solibext)
491 {
492 return FileSpec::eEnumerateDirectoryResultNext;
493 }
494
495 Error plugin_load_error;
496 debugger->LoadPlugin (plugin_file_spec, plugin_load_error);
497
498 return FileSpec::eEnumerateDirectoryResultNext;
499 }
500
501 else if (file_type == FileSpec::eFileTypeUnknown ||
502 file_type == FileSpec::eFileTypeDirectory ||
503 file_type == FileSpec::eFileTypeSymbolicLink )
504 {
505 // Try and recurse into anything that a directory or symbolic link.
506 // We must also do this for unknown as sometimes the directory enumeration
507 // might be enumerating a file system that doesn't have correct file type
508 // information.
509 return FileSpec::eEnumerateDirectoryResultEnter;
510 }
511
512 return FileSpec::eEnumerateDirectoryResultNext;
513 }
514
515 void
InstanceInitialize()516 Debugger::InstanceInitialize ()
517 {
518 FileSpec dir_spec;
519 const bool find_directories = true;
520 const bool find_files = true;
521 const bool find_other = true;
522 char dir_path[PATH_MAX];
523 if (HostInfo::GetLLDBPath(ePathTypeLLDBSystemPlugins, dir_spec))
524 {
525 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
526 {
527 FileSpec::EnumerateDirectory (dir_path,
528 find_directories,
529 find_files,
530 find_other,
531 LoadPluginCallback,
532 this);
533 }
534 }
535
536 if (HostInfo::GetLLDBPath(ePathTypeLLDBUserPlugins, dir_spec))
537 {
538 if (dir_spec.Exists() && dir_spec.GetPath(dir_path, sizeof(dir_path)))
539 {
540 FileSpec::EnumerateDirectory (dir_path,
541 find_directories,
542 find_files,
543 find_other,
544 LoadPluginCallback,
545 this);
546 }
547 }
548
549 PluginManager::DebuggerInitialize (*this);
550 }
551
552 DebuggerSP
CreateInstance(lldb::LogOutputCallback log_callback,void * baton)553 Debugger::CreateInstance (lldb::LogOutputCallback log_callback, void *baton)
554 {
555 DebuggerSP debugger_sp (new Debugger(log_callback, baton));
556 if (lldb_initialized)
557 {
558 Mutex::Locker locker (GetDebuggerListMutex ());
559 GetDebuggerList().push_back(debugger_sp);
560 }
561 debugger_sp->InstanceInitialize ();
562 return debugger_sp;
563 }
564
565 void
Destroy(DebuggerSP & debugger_sp)566 Debugger::Destroy (DebuggerSP &debugger_sp)
567 {
568 if (debugger_sp.get() == NULL)
569 return;
570
571 debugger_sp->Clear();
572
573 if (lldb_initialized)
574 {
575 Mutex::Locker locker (GetDebuggerListMutex ());
576 DebuggerList &debugger_list = GetDebuggerList ();
577 DebuggerList::iterator pos, end = debugger_list.end();
578 for (pos = debugger_list.begin (); pos != end; ++pos)
579 {
580 if ((*pos).get() == debugger_sp.get())
581 {
582 debugger_list.erase (pos);
583 return;
584 }
585 }
586 }
587 }
588
589 DebuggerSP
FindDebuggerWithInstanceName(const ConstString & instance_name)590 Debugger::FindDebuggerWithInstanceName (const ConstString &instance_name)
591 {
592 DebuggerSP debugger_sp;
593 if (lldb_initialized)
594 {
595 Mutex::Locker locker (GetDebuggerListMutex ());
596 DebuggerList &debugger_list = GetDebuggerList();
597 DebuggerList::iterator pos, end = debugger_list.end();
598
599 for (pos = debugger_list.begin(); pos != end; ++pos)
600 {
601 if ((*pos).get()->m_instance_name == instance_name)
602 {
603 debugger_sp = *pos;
604 break;
605 }
606 }
607 }
608 return debugger_sp;
609 }
610
611 TargetSP
FindTargetWithProcessID(lldb::pid_t pid)612 Debugger::FindTargetWithProcessID (lldb::pid_t pid)
613 {
614 TargetSP target_sp;
615 if (lldb_initialized)
616 {
617 Mutex::Locker locker (GetDebuggerListMutex ());
618 DebuggerList &debugger_list = GetDebuggerList();
619 DebuggerList::iterator pos, end = debugger_list.end();
620 for (pos = debugger_list.begin(); pos != end; ++pos)
621 {
622 target_sp = (*pos)->GetTargetList().FindTargetWithProcessID (pid);
623 if (target_sp)
624 break;
625 }
626 }
627 return target_sp;
628 }
629
630 TargetSP
FindTargetWithProcess(Process * process)631 Debugger::FindTargetWithProcess (Process *process)
632 {
633 TargetSP target_sp;
634 if (lldb_initialized)
635 {
636 Mutex::Locker locker (GetDebuggerListMutex ());
637 DebuggerList &debugger_list = GetDebuggerList();
638 DebuggerList::iterator pos, end = debugger_list.end();
639 for (pos = debugger_list.begin(); pos != end; ++pos)
640 {
641 target_sp = (*pos)->GetTargetList().FindTargetWithProcess (process);
642 if (target_sp)
643 break;
644 }
645 }
646 return target_sp;
647 }
648
Debugger(lldb::LogOutputCallback log_callback,void * baton)649 Debugger::Debugger(lldb::LogOutputCallback log_callback, void *baton) :
650 UserID(g_unique_id++),
651 Properties(OptionValuePropertiesSP(new OptionValueProperties())),
652 m_input_file_sp(new StreamFile(stdin, false)),
653 m_output_file_sp(new StreamFile(stdout, false)),
654 m_error_file_sp(new StreamFile(stderr, false)),
655 m_terminal_state(),
656 m_target_list(*this),
657 m_platform_list(),
658 m_listener("lldb.Debugger"),
659 m_source_manager_ap(),
660 m_source_file_cache(),
661 m_command_interpreter_ap(new CommandInterpreter(*this, eScriptLanguageDefault, false)),
662 m_input_reader_stack(),
663 m_instance_name(),
664 m_loaded_plugins(),
665 m_event_handler_thread (),
666 m_io_handler_thread (),
667 m_sync_broadcaster (NULL, "lldb.debugger.sync")
668 {
669 char instance_cstr[256];
670 snprintf(instance_cstr, sizeof(instance_cstr), "debugger_%d", (int)GetID());
671 m_instance_name.SetCString(instance_cstr);
672 if (log_callback)
673 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton));
674 m_command_interpreter_ap->Initialize ();
675 // Always add our default platform to the platform list
676 PlatformSP default_platform_sp (Platform::GetHostPlatform());
677 assert (default_platform_sp.get());
678 m_platform_list.Append (default_platform_sp, true);
679
680 m_collection_sp->Initialize (g_properties);
681 m_collection_sp->AppendProperty (ConstString("target"),
682 ConstString("Settings specify to debugging targets."),
683 true,
684 Target::GetGlobalProperties()->GetValueProperties());
685 m_collection_sp->AppendProperty (ConstString("platform"),
686 ConstString("Platform settings."),
687 true,
688 Platform::GetGlobalPlatformProperties()->GetValueProperties());
689 if (m_command_interpreter_ap.get())
690 {
691 m_collection_sp->AppendProperty (ConstString("interpreter"),
692 ConstString("Settings specify to the debugger's command interpreter."),
693 true,
694 m_command_interpreter_ap->GetValueProperties());
695 }
696 OptionValueSInt64 *term_width = m_collection_sp->GetPropertyAtIndexAsOptionValueSInt64 (NULL, ePropertyTerminalWidth);
697 term_width->SetMinimumValue(10);
698 term_width->SetMaximumValue(1024);
699
700 // Turn off use-color if this is a dumb terminal.
701 const char *term = getenv ("TERM");
702 if (term && !strcmp (term, "dumb"))
703 SetUseColor (false);
704 }
705
~Debugger()706 Debugger::~Debugger ()
707 {
708 Clear();
709 }
710
711 void
Clear()712 Debugger::Clear()
713 {
714 ClearIOHandlers();
715 StopIOHandlerThread();
716 StopEventHandlerThread();
717 m_listener.Clear();
718 int num_targets = m_target_list.GetNumTargets();
719 for (int i = 0; i < num_targets; i++)
720 {
721 TargetSP target_sp (m_target_list.GetTargetAtIndex (i));
722 if (target_sp)
723 {
724 ProcessSP process_sp (target_sp->GetProcessSP());
725 if (process_sp)
726 process_sp->Finalize();
727 target_sp->Destroy();
728 }
729 }
730 BroadcasterManager::Clear ();
731
732 // Close the input file _before_ we close the input read communications class
733 // as it does NOT own the input file, our m_input_file does.
734 m_terminal_state.Clear();
735 if (m_input_file_sp)
736 m_input_file_sp->GetFile().Close ();
737
738 m_command_interpreter_ap->Clear();
739 }
740
741 bool
GetCloseInputOnEOF() const742 Debugger::GetCloseInputOnEOF () const
743 {
744 // return m_input_comm.GetCloseOnEOF();
745 return false;
746 }
747
748 void
SetCloseInputOnEOF(bool b)749 Debugger::SetCloseInputOnEOF (bool b)
750 {
751 // m_input_comm.SetCloseOnEOF(b);
752 }
753
754 bool
GetAsyncExecution()755 Debugger::GetAsyncExecution ()
756 {
757 return !m_command_interpreter_ap->GetSynchronous();
758 }
759
760 void
SetAsyncExecution(bool async_execution)761 Debugger::SetAsyncExecution (bool async_execution)
762 {
763 m_command_interpreter_ap->SetSynchronous (!async_execution);
764 }
765
766
767 void
SetInputFileHandle(FILE * fh,bool tranfer_ownership)768 Debugger::SetInputFileHandle (FILE *fh, bool tranfer_ownership)
769 {
770 if (m_input_file_sp)
771 m_input_file_sp->GetFile().SetStream (fh, tranfer_ownership);
772 else
773 m_input_file_sp.reset (new StreamFile (fh, tranfer_ownership));
774
775 File &in_file = m_input_file_sp->GetFile();
776 if (in_file.IsValid() == false)
777 in_file.SetStream (stdin, true);
778
779 // Save away the terminal state if that is relevant, so that we can restore it in RestoreInputState.
780 SaveInputTerminalState ();
781 }
782
783 void
SetOutputFileHandle(FILE * fh,bool tranfer_ownership)784 Debugger::SetOutputFileHandle (FILE *fh, bool tranfer_ownership)
785 {
786 if (m_output_file_sp)
787 m_output_file_sp->GetFile().SetStream (fh, tranfer_ownership);
788 else
789 m_output_file_sp.reset (new StreamFile (fh, tranfer_ownership));
790
791 File &out_file = m_output_file_sp->GetFile();
792 if (out_file.IsValid() == false)
793 out_file.SetStream (stdout, false);
794
795 // do not create the ScriptInterpreter just for setting the output file handle
796 // as the constructor will know how to do the right thing on its own
797 const bool can_create = false;
798 ScriptInterpreter* script_interpreter = GetCommandInterpreter().GetScriptInterpreter(can_create);
799 if (script_interpreter)
800 script_interpreter->ResetOutputFileHandle (fh);
801 }
802
803 void
SetErrorFileHandle(FILE * fh,bool tranfer_ownership)804 Debugger::SetErrorFileHandle (FILE *fh, bool tranfer_ownership)
805 {
806 if (m_error_file_sp)
807 m_error_file_sp->GetFile().SetStream (fh, tranfer_ownership);
808 else
809 m_error_file_sp.reset (new StreamFile (fh, tranfer_ownership));
810
811 File &err_file = m_error_file_sp->GetFile();
812 if (err_file.IsValid() == false)
813 err_file.SetStream (stderr, false);
814 }
815
816 void
SaveInputTerminalState()817 Debugger::SaveInputTerminalState ()
818 {
819 if (m_input_file_sp)
820 {
821 File &in_file = m_input_file_sp->GetFile();
822 if (in_file.GetDescriptor() != File::kInvalidDescriptor)
823 m_terminal_state.Save(in_file.GetDescriptor(), true);
824 }
825 }
826
827 void
RestoreInputTerminalState()828 Debugger::RestoreInputTerminalState ()
829 {
830 m_terminal_state.Restore();
831 }
832
833 ExecutionContext
GetSelectedExecutionContext()834 Debugger::GetSelectedExecutionContext ()
835 {
836 ExecutionContext exe_ctx;
837 TargetSP target_sp(GetSelectedTarget());
838 exe_ctx.SetTargetSP (target_sp);
839
840 if (target_sp)
841 {
842 ProcessSP process_sp (target_sp->GetProcessSP());
843 exe_ctx.SetProcessSP (process_sp);
844 if (process_sp && process_sp->IsRunning() == false)
845 {
846 ThreadSP thread_sp (process_sp->GetThreadList().GetSelectedThread());
847 if (thread_sp)
848 {
849 exe_ctx.SetThreadSP (thread_sp);
850 exe_ctx.SetFrameSP (thread_sp->GetSelectedFrame());
851 if (exe_ctx.GetFramePtr() == NULL)
852 exe_ctx.SetFrameSP (thread_sp->GetStackFrameAtIndex (0));
853 }
854 }
855 }
856 return exe_ctx;
857 }
858
859 void
DispatchInputInterrupt()860 Debugger::DispatchInputInterrupt ()
861 {
862 Mutex::Locker locker (m_input_reader_stack.GetMutex());
863 IOHandlerSP reader_sp (m_input_reader_stack.Top());
864 if (reader_sp)
865 reader_sp->Interrupt();
866 }
867
868 void
DispatchInputEndOfFile()869 Debugger::DispatchInputEndOfFile ()
870 {
871 Mutex::Locker locker (m_input_reader_stack.GetMutex());
872 IOHandlerSP reader_sp (m_input_reader_stack.Top());
873 if (reader_sp)
874 reader_sp->GotEOF();
875 }
876
877 void
ClearIOHandlers()878 Debugger::ClearIOHandlers ()
879 {
880 // The bottom input reader should be the main debugger input reader. We do not want to close that one here.
881 Mutex::Locker locker (m_input_reader_stack.GetMutex());
882 while (m_input_reader_stack.GetSize() > 1)
883 {
884 IOHandlerSP reader_sp (m_input_reader_stack.Top());
885 if (reader_sp)
886 PopIOHandler (reader_sp);
887 }
888 }
889
890 void
ExecuteIOHandlers()891 Debugger::ExecuteIOHandlers()
892 {
893 while (1)
894 {
895 IOHandlerSP reader_sp(m_input_reader_stack.Top());
896 if (!reader_sp)
897 break;
898
899 reader_sp->Run();
900
901 // Remove all input readers that are done from the top of the stack
902 while (1)
903 {
904 IOHandlerSP top_reader_sp = m_input_reader_stack.Top();
905 if (top_reader_sp && top_reader_sp->GetIsDone())
906 PopIOHandler (top_reader_sp);
907 else
908 break;
909 }
910 }
911 ClearIOHandlers();
912 }
913
914 bool
IsTopIOHandler(const lldb::IOHandlerSP & reader_sp)915 Debugger::IsTopIOHandler (const lldb::IOHandlerSP& reader_sp)
916 {
917 return m_input_reader_stack.IsTop (reader_sp);
918 }
919
920 void
PrintAsync(const char * s,size_t len,bool is_stdout)921 Debugger::PrintAsync (const char *s, size_t len, bool is_stdout)
922 {
923 lldb::StreamFileSP stream = is_stdout ? GetOutputFile() : GetErrorFile();
924 m_input_reader_stack.PrintAsync(stream.get(), s, len);
925 }
926
927 ConstString
GetTopIOHandlerControlSequence(char ch)928 Debugger::GetTopIOHandlerControlSequence(char ch)
929 {
930 return m_input_reader_stack.GetTopIOHandlerControlSequence (ch);
931 }
932
933 const char *
GetIOHandlerCommandPrefix()934 Debugger::GetIOHandlerCommandPrefix()
935 {
936 return m_input_reader_stack.GetTopIOHandlerCommandPrefix();
937 }
938
939 const char *
GetIOHandlerHelpPrologue()940 Debugger::GetIOHandlerHelpPrologue()
941 {
942 return m_input_reader_stack.GetTopIOHandlerHelpPrologue();
943 }
944
945 void
RunIOHandler(const IOHandlerSP & reader_sp)946 Debugger::RunIOHandler (const IOHandlerSP& reader_sp)
947 {
948 PushIOHandler (reader_sp);
949
950 IOHandlerSP top_reader_sp = reader_sp;
951 while (top_reader_sp)
952 {
953 top_reader_sp->Run();
954
955 if (top_reader_sp.get() == reader_sp.get())
956 {
957 if (PopIOHandler (reader_sp))
958 break;
959 }
960
961 while (1)
962 {
963 top_reader_sp = m_input_reader_stack.Top();
964 if (top_reader_sp && top_reader_sp->GetIsDone())
965 PopIOHandler (top_reader_sp);
966 else
967 break;
968 }
969 }
970 }
971
972 void
AdoptTopIOHandlerFilesIfInvalid(StreamFileSP & in,StreamFileSP & out,StreamFileSP & err)973 Debugger::AdoptTopIOHandlerFilesIfInvalid (StreamFileSP &in, StreamFileSP &out, StreamFileSP &err)
974 {
975 // Before an IOHandler runs, it must have in/out/err streams.
976 // This function is called when one ore more of the streams
977 // are NULL. We use the top input reader's in/out/err streams,
978 // or fall back to the debugger file handles, or we fall back
979 // onto stdin/stdout/stderr as a last resort.
980
981 Mutex::Locker locker (m_input_reader_stack.GetMutex());
982 IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
983 // If no STDIN has been set, then set it appropriately
984 if (!in)
985 {
986 if (top_reader_sp)
987 in = top_reader_sp->GetInputStreamFile();
988 else
989 in = GetInputFile();
990
991 // If there is nothing, use stdin
992 if (!in)
993 in = StreamFileSP(new StreamFile(stdin, false));
994 }
995 // If no STDOUT has been set, then set it appropriately
996 if (!out)
997 {
998 if (top_reader_sp)
999 out = top_reader_sp->GetOutputStreamFile();
1000 else
1001 out = GetOutputFile();
1002
1003 // If there is nothing, use stdout
1004 if (!out)
1005 out = StreamFileSP(new StreamFile(stdout, false));
1006 }
1007 // If no STDERR has been set, then set it appropriately
1008 if (!err)
1009 {
1010 if (top_reader_sp)
1011 err = top_reader_sp->GetErrorStreamFile();
1012 else
1013 err = GetErrorFile();
1014
1015 // If there is nothing, use stderr
1016 if (!err)
1017 err = StreamFileSP(new StreamFile(stdout, false));
1018
1019 }
1020 }
1021
1022 void
PushIOHandler(const IOHandlerSP & reader_sp)1023 Debugger::PushIOHandler (const IOHandlerSP& reader_sp)
1024 {
1025 if (!reader_sp)
1026 return;
1027
1028 Mutex::Locker locker (m_input_reader_stack.GetMutex());
1029
1030 // Get the current top input reader...
1031 IOHandlerSP top_reader_sp (m_input_reader_stack.Top());
1032
1033 // Don't push the same IO handler twice...
1034 if (reader_sp == top_reader_sp)
1035 return;
1036
1037 // Push our new input reader
1038 m_input_reader_stack.Push (reader_sp);
1039 reader_sp->Activate();
1040
1041 // Interrupt the top input reader to it will exit its Run() function
1042 // and let this new input reader take over
1043 if (top_reader_sp)
1044 {
1045 top_reader_sp->Deactivate();
1046 top_reader_sp->Cancel();
1047 }
1048 }
1049
1050 bool
PopIOHandler(const IOHandlerSP & pop_reader_sp)1051 Debugger::PopIOHandler (const IOHandlerSP& pop_reader_sp)
1052 {
1053 if (! pop_reader_sp)
1054 return false;
1055
1056 Mutex::Locker locker (m_input_reader_stack.GetMutex());
1057
1058 // The reader on the stop of the stack is done, so let the next
1059 // read on the stack refresh its prompt and if there is one...
1060 if (m_input_reader_stack.IsEmpty())
1061 return false;
1062
1063 IOHandlerSP reader_sp(m_input_reader_stack.Top());
1064
1065 if (pop_reader_sp != reader_sp)
1066 return false;
1067
1068 reader_sp->Deactivate();
1069 reader_sp->Cancel();
1070 m_input_reader_stack.Pop ();
1071
1072 reader_sp = m_input_reader_stack.Top();
1073 if (reader_sp)
1074 reader_sp->Activate();
1075
1076 return true;
1077 }
1078
1079 StreamSP
GetAsyncOutputStream()1080 Debugger::GetAsyncOutputStream ()
1081 {
1082 return StreamSP (new StreamAsynchronousIO (*this, true));
1083 }
1084
1085 StreamSP
GetAsyncErrorStream()1086 Debugger::GetAsyncErrorStream ()
1087 {
1088 return StreamSP (new StreamAsynchronousIO (*this, false));
1089 }
1090
1091 size_t
GetNumDebuggers()1092 Debugger::GetNumDebuggers()
1093 {
1094 if (lldb_initialized)
1095 {
1096 Mutex::Locker locker (GetDebuggerListMutex ());
1097 return GetDebuggerList().size();
1098 }
1099 return 0;
1100 }
1101
1102 lldb::DebuggerSP
GetDebuggerAtIndex(size_t index)1103 Debugger::GetDebuggerAtIndex (size_t index)
1104 {
1105 DebuggerSP debugger_sp;
1106
1107 if (lldb_initialized)
1108 {
1109 Mutex::Locker locker (GetDebuggerListMutex ());
1110 DebuggerList &debugger_list = GetDebuggerList();
1111
1112 if (index < debugger_list.size())
1113 debugger_sp = debugger_list[index];
1114 }
1115
1116 return debugger_sp;
1117 }
1118
1119 DebuggerSP
FindDebuggerWithID(lldb::user_id_t id)1120 Debugger::FindDebuggerWithID (lldb::user_id_t id)
1121 {
1122 DebuggerSP debugger_sp;
1123
1124 if (lldb_initialized)
1125 {
1126 Mutex::Locker locker (GetDebuggerListMutex ());
1127 DebuggerList &debugger_list = GetDebuggerList();
1128 DebuggerList::iterator pos, end = debugger_list.end();
1129 for (pos = debugger_list.begin(); pos != end; ++pos)
1130 {
1131 if ((*pos).get()->GetID() == id)
1132 {
1133 debugger_sp = *pos;
1134 break;
1135 }
1136 }
1137 }
1138 return debugger_sp;
1139 }
1140
1141 #if 0
1142 static void
1143 TestPromptFormats (StackFrame *frame)
1144 {
1145 if (frame == NULL)
1146 return;
1147
1148 StreamString s;
1149 const char *prompt_format =
1150 "{addr = '${addr}'\n}"
1151 "{addr-file-or-load = '${addr-file-or-load}'\n}"
1152 "{current-pc-arrow = '${current-pc-arrow}'\n}"
1153 "{process.id = '${process.id}'\n}"
1154 "{process.name = '${process.name}'\n}"
1155 "{process.file.basename = '${process.file.basename}'\n}"
1156 "{process.file.fullpath = '${process.file.fullpath}'\n}"
1157 "{thread.id = '${thread.id}'\n}"
1158 "{thread.index = '${thread.index}'\n}"
1159 "{thread.name = '${thread.name}'\n}"
1160 "{thread.queue = '${thread.queue}'\n}"
1161 "{thread.stop-reason = '${thread.stop-reason}'\n}"
1162 "{target.arch = '${target.arch}'\n}"
1163 "{module.file.basename = '${module.file.basename}'\n}"
1164 "{module.file.fullpath = '${module.file.fullpath}'\n}"
1165 "{file.basename = '${file.basename}'\n}"
1166 "{file.fullpath = '${file.fullpath}'\n}"
1167 "{frame.index = '${frame.index}'\n}"
1168 "{frame.pc = '${frame.pc}'\n}"
1169 "{frame.sp = '${frame.sp}'\n}"
1170 "{frame.fp = '${frame.fp}'\n}"
1171 "{frame.flags = '${frame.flags}'\n}"
1172 "{frame.reg.rdi = '${frame.reg.rdi}'\n}"
1173 "{frame.reg.rip = '${frame.reg.rip}'\n}"
1174 "{frame.reg.rsp = '${frame.reg.rsp}'\n}"
1175 "{frame.reg.rbp = '${frame.reg.rbp}'\n}"
1176 "{frame.reg.rflags = '${frame.reg.rflags}'\n}"
1177 "{frame.reg.xmm0 = '${frame.reg.xmm0}'\n}"
1178 "{frame.reg.carp = '${frame.reg.carp}'\n}"
1179 "{function.id = '${function.id}'\n}"
1180 "{function.changed = '${function.changed}'\n}"
1181 "{function.initial-function = '${function.initial-function}'\n}"
1182 "{function.name = '${function.name}'\n}"
1183 "{function.name-without-args = '${function.name-without-args}'\n}"
1184 "{function.name-with-args = '${function.name-with-args}'\n}"
1185 "{function.addr-offset = '${function.addr-offset}'\n}"
1186 "{function.concrete-only-addr-offset-no-padding = '${function.concrete-only-addr-offset-no-padding}'\n}"
1187 "{function.line-offset = '${function.line-offset}'\n}"
1188 "{function.pc-offset = '${function.pc-offset}'\n}"
1189 "{line.file.basename = '${line.file.basename}'\n}"
1190 "{line.file.fullpath = '${line.file.fullpath}'\n}"
1191 "{line.number = '${line.number}'\n}"
1192 "{line.start-addr = '${line.start-addr}'\n}"
1193 "{line.end-addr = '${line.end-addr}'\n}"
1194 ;
1195
1196 SymbolContext sc (frame->GetSymbolContext(eSymbolContextEverything));
1197 ExecutionContext exe_ctx;
1198 frame->CalculateExecutionContext(exe_ctx);
1199 if (Debugger::FormatPrompt (prompt_format, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), s))
1200 {
1201 printf("%s\n", s.GetData());
1202 }
1203 else
1204 {
1205 printf ("what we got: %s\n", s.GetData());
1206 }
1207 }
1208 #endif
1209
1210 bool
FormatDisassemblerAddress(const FormatEntity::Entry * format,const SymbolContext * sc,const SymbolContext * prev_sc,const ExecutionContext * exe_ctx,const Address * addr,Stream & s)1211 Debugger::FormatDisassemblerAddress (const FormatEntity::Entry *format,
1212 const SymbolContext *sc,
1213 const SymbolContext *prev_sc,
1214 const ExecutionContext *exe_ctx,
1215 const Address *addr,
1216 Stream &s)
1217 {
1218 FormatEntity::Entry format_entry;
1219
1220 if (format == NULL)
1221 {
1222 if (exe_ctx != NULL && exe_ctx->HasTargetScope())
1223 format = exe_ctx->GetTargetRef().GetDebugger().GetDisassemblyFormat();
1224 if (format == NULL)
1225 {
1226 FormatEntity::Parse("${addr}: ", format_entry);
1227 format = &format_entry;
1228 }
1229 }
1230 bool function_changed = false;
1231 bool initial_function = false;
1232 if (prev_sc && (prev_sc->function || prev_sc->symbol))
1233 {
1234 if (sc && (sc->function || sc->symbol))
1235 {
1236 if (prev_sc->symbol && sc->symbol)
1237 {
1238 if (!sc->symbol->Compare (prev_sc->symbol->GetName(), prev_sc->symbol->GetType()))
1239 {
1240 function_changed = true;
1241 }
1242 }
1243 else if (prev_sc->function && sc->function)
1244 {
1245 if (prev_sc->function->GetMangled() != sc->function->GetMangled())
1246 {
1247 function_changed = true;
1248 }
1249 }
1250 }
1251 }
1252 // The first context on a list of instructions will have a prev_sc that
1253 // has no Function or Symbol -- if SymbolContext had an IsValid() method, it
1254 // would return false. But we do get a prev_sc pointer.
1255 if ((sc && (sc->function || sc->symbol))
1256 && prev_sc && (prev_sc->function == NULL && prev_sc->symbol == NULL))
1257 {
1258 initial_function = true;
1259 }
1260 return FormatEntity::Format(*format, s, sc, exe_ctx, addr, NULL, function_changed, initial_function);
1261 }
1262
1263
1264 void
SetLoggingCallback(lldb::LogOutputCallback log_callback,void * baton)1265 Debugger::SetLoggingCallback (lldb::LogOutputCallback log_callback, void *baton)
1266 {
1267 // For simplicity's sake, I am not going to deal with how to close down any
1268 // open logging streams, I just redirect everything from here on out to the
1269 // callback.
1270 m_log_callback_stream_sp.reset (new StreamCallback (log_callback, baton));
1271 }
1272
1273 bool
EnableLog(const char * channel,const char ** categories,const char * log_file,uint32_t log_options,Stream & error_stream)1274 Debugger::EnableLog (const char *channel, const char **categories, const char *log_file, uint32_t log_options, Stream &error_stream)
1275 {
1276 StreamSP log_stream_sp;
1277 if (m_log_callback_stream_sp)
1278 {
1279 log_stream_sp = m_log_callback_stream_sp;
1280 // For now when using the callback mode you always get thread & timestamp.
1281 log_options |= LLDB_LOG_OPTION_PREPEND_TIMESTAMP | LLDB_LOG_OPTION_PREPEND_THREAD_NAME;
1282 }
1283 else if (log_file == NULL || *log_file == '\0')
1284 {
1285 log_stream_sp = GetOutputFile();
1286 }
1287 else
1288 {
1289 LogStreamMap::iterator pos = m_log_streams.find(log_file);
1290 if (pos != m_log_streams.end())
1291 log_stream_sp = pos->second.lock();
1292 if (!log_stream_sp)
1293 {
1294 uint32_t options = File::eOpenOptionWrite | File::eOpenOptionCanCreate
1295 | File::eOpenOptionCloseOnExec | File::eOpenOptionAppend;
1296 if (! (log_options & LLDB_LOG_OPTION_APPEND))
1297 options |= File::eOpenOptionTruncate;
1298
1299 log_stream_sp.reset (new StreamFile (log_file, options));
1300 m_log_streams[log_file] = log_stream_sp;
1301 }
1302 }
1303 assert (log_stream_sp.get());
1304
1305 if (log_options == 0)
1306 log_options = LLDB_LOG_OPTION_PREPEND_THREAD_NAME | LLDB_LOG_OPTION_THREADSAFE;
1307
1308 return Log::EnableLogChannel(log_stream_sp, log_options, channel, categories, error_stream);
1309 }
1310
1311 SourceManager &
GetSourceManager()1312 Debugger::GetSourceManager ()
1313 {
1314 if (m_source_manager_ap.get() == NULL)
1315 m_source_manager_ap.reset (new SourceManager (shared_from_this()));
1316 return *m_source_manager_ap;
1317 }
1318
1319
1320
1321 // This function handles events that were broadcast by the process.
1322 void
HandleBreakpointEvent(const EventSP & event_sp)1323 Debugger::HandleBreakpointEvent (const EventSP &event_sp)
1324 {
1325 using namespace lldb;
1326 const uint32_t event_type = Breakpoint::BreakpointEventData::GetBreakpointEventTypeFromEvent (event_sp);
1327
1328 // if (event_type & eBreakpointEventTypeAdded
1329 // || event_type & eBreakpointEventTypeRemoved
1330 // || event_type & eBreakpointEventTypeEnabled
1331 // || event_type & eBreakpointEventTypeDisabled
1332 // || event_type & eBreakpointEventTypeCommandChanged
1333 // || event_type & eBreakpointEventTypeConditionChanged
1334 // || event_type & eBreakpointEventTypeIgnoreChanged
1335 // || event_type & eBreakpointEventTypeLocationsResolved)
1336 // {
1337 // // Don't do anything about these events, since the breakpoint commands already echo these actions.
1338 // }
1339 //
1340 if (event_type & eBreakpointEventTypeLocationsAdded)
1341 {
1342 uint32_t num_new_locations = Breakpoint::BreakpointEventData::GetNumBreakpointLocationsFromEvent(event_sp);
1343 if (num_new_locations > 0)
1344 {
1345 BreakpointSP breakpoint = Breakpoint::BreakpointEventData::GetBreakpointFromEvent(event_sp);
1346 StreamSP output_sp (GetAsyncOutputStream());
1347 if (output_sp)
1348 {
1349 output_sp->Printf("%d location%s added to breakpoint %d\n",
1350 num_new_locations,
1351 num_new_locations == 1 ? "" : "s",
1352 breakpoint->GetID());
1353 output_sp->Flush();
1354 }
1355 }
1356 }
1357 // else if (event_type & eBreakpointEventTypeLocationsRemoved)
1358 // {
1359 // // These locations just get disabled, not sure it is worth spamming folks about this on the command line.
1360 // }
1361 // else if (event_type & eBreakpointEventTypeLocationsResolved)
1362 // {
1363 // // This might be an interesting thing to note, but I'm going to leave it quiet for now, it just looked noisy.
1364 // }
1365 }
1366
1367 size_t
GetProcessSTDOUT(Process * process,Stream * stream)1368 Debugger::GetProcessSTDOUT (Process *process, Stream *stream)
1369 {
1370 size_t total_bytes = 0;
1371 if (stream == NULL)
1372 stream = GetOutputFile().get();
1373
1374 if (stream)
1375 {
1376 // The process has stuff waiting for stdout; get it and write it out to the appropriate place.
1377 if (process == NULL)
1378 {
1379 TargetSP target_sp = GetTargetList().GetSelectedTarget();
1380 if (target_sp)
1381 process = target_sp->GetProcessSP().get();
1382 }
1383 if (process)
1384 {
1385 Error error;
1386 size_t len;
1387 char stdio_buffer[1024];
1388 while ((len = process->GetSTDOUT (stdio_buffer, sizeof (stdio_buffer), error)) > 0)
1389 {
1390 stream->Write(stdio_buffer, len);
1391 total_bytes += len;
1392 }
1393 }
1394 stream->Flush();
1395 }
1396 return total_bytes;
1397 }
1398
1399 size_t
GetProcessSTDERR(Process * process,Stream * stream)1400 Debugger::GetProcessSTDERR (Process *process, Stream *stream)
1401 {
1402 size_t total_bytes = 0;
1403 if (stream == NULL)
1404 stream = GetOutputFile().get();
1405
1406 if (stream)
1407 {
1408 // The process has stuff waiting for stderr; get it and write it out to the appropriate place.
1409 if (process == NULL)
1410 {
1411 TargetSP target_sp = GetTargetList().GetSelectedTarget();
1412 if (target_sp)
1413 process = target_sp->GetProcessSP().get();
1414 }
1415 if (process)
1416 {
1417 Error error;
1418 size_t len;
1419 char stdio_buffer[1024];
1420 while ((len = process->GetSTDERR (stdio_buffer, sizeof (stdio_buffer), error)) > 0)
1421 {
1422 stream->Write(stdio_buffer, len);
1423 total_bytes += len;
1424 }
1425 }
1426 stream->Flush();
1427 }
1428 return total_bytes;
1429 }
1430
1431
1432 // This function handles events that were broadcast by the process.
1433 void
HandleProcessEvent(const EventSP & event_sp)1434 Debugger::HandleProcessEvent (const EventSP &event_sp)
1435 {
1436 using namespace lldb;
1437 const uint32_t event_type = event_sp->GetType();
1438 ProcessSP process_sp = Process::ProcessEventData::GetProcessFromEvent(event_sp.get());
1439
1440 StreamSP output_stream_sp = GetAsyncOutputStream();
1441 StreamSP error_stream_sp = GetAsyncErrorStream();
1442 const bool gui_enabled = IsForwardingEvents();
1443
1444 if (!gui_enabled)
1445 {
1446 bool pop_process_io_handler = false;
1447 assert (process_sp);
1448
1449 bool state_is_stopped = false;
1450 const bool got_state_changed = (event_type & Process::eBroadcastBitStateChanged) != 0;
1451 const bool got_stdout = (event_type & Process::eBroadcastBitSTDOUT) != 0;
1452 const bool got_stderr = (event_type & Process::eBroadcastBitSTDERR) != 0;
1453 if (got_state_changed)
1454 {
1455 StateType event_state = Process::ProcessEventData::GetStateFromEvent (event_sp.get());
1456 state_is_stopped = StateIsStoppedState(event_state, false);
1457 }
1458
1459 // Display running state changes first before any STDIO
1460 if (got_state_changed && !state_is_stopped)
1461 {
1462 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler);
1463 }
1464
1465 // Now display and STDOUT
1466 if (got_stdout || got_state_changed)
1467 {
1468 GetProcessSTDOUT (process_sp.get(), output_stream_sp.get());
1469 }
1470
1471 // Now display and STDERR
1472 if (got_stderr || got_state_changed)
1473 {
1474 GetProcessSTDERR (process_sp.get(), error_stream_sp.get());
1475 }
1476
1477 // Now display any stopped state changes after any STDIO
1478 if (got_state_changed && state_is_stopped)
1479 {
1480 Process::HandleProcessStateChangedEvent (event_sp, output_stream_sp.get(), pop_process_io_handler);
1481 }
1482
1483 output_stream_sp->Flush();
1484 error_stream_sp->Flush();
1485
1486 if (pop_process_io_handler)
1487 process_sp->PopProcessIOHandler();
1488 }
1489 }
1490
1491 void
HandleThreadEvent(const EventSP & event_sp)1492 Debugger::HandleThreadEvent (const EventSP &event_sp)
1493 {
1494 // At present the only thread event we handle is the Frame Changed event,
1495 // and all we do for that is just reprint the thread status for that thread.
1496 using namespace lldb;
1497 const uint32_t event_type = event_sp->GetType();
1498 if (event_type == Thread::eBroadcastBitStackChanged ||
1499 event_type == Thread::eBroadcastBitThreadSelected )
1500 {
1501 ThreadSP thread_sp (Thread::ThreadEventData::GetThreadFromEvent (event_sp.get()));
1502 if (thread_sp)
1503 {
1504 thread_sp->GetStatus(*GetAsyncOutputStream(), 0, 1, 1);
1505 }
1506 }
1507 }
1508
1509 bool
IsForwardingEvents()1510 Debugger::IsForwardingEvents ()
1511 {
1512 return (bool)m_forward_listener_sp;
1513 }
1514
1515 void
EnableForwardEvents(const ListenerSP & listener_sp)1516 Debugger::EnableForwardEvents (const ListenerSP &listener_sp)
1517 {
1518 m_forward_listener_sp = listener_sp;
1519 }
1520
1521 void
CancelForwardEvents(const ListenerSP & listener_sp)1522 Debugger::CancelForwardEvents (const ListenerSP &listener_sp)
1523 {
1524 m_forward_listener_sp.reset();
1525 }
1526
1527
1528 void
DefaultEventHandler()1529 Debugger::DefaultEventHandler()
1530 {
1531 Listener& listener(GetListener());
1532 ConstString broadcaster_class_target(Target::GetStaticBroadcasterClass());
1533 ConstString broadcaster_class_process(Process::GetStaticBroadcasterClass());
1534 ConstString broadcaster_class_thread(Thread::GetStaticBroadcasterClass());
1535 BroadcastEventSpec target_event_spec (broadcaster_class_target,
1536 Target::eBroadcastBitBreakpointChanged);
1537
1538 BroadcastEventSpec process_event_spec (broadcaster_class_process,
1539 Process::eBroadcastBitStateChanged |
1540 Process::eBroadcastBitSTDOUT |
1541 Process::eBroadcastBitSTDERR);
1542
1543 BroadcastEventSpec thread_event_spec (broadcaster_class_thread,
1544 Thread::eBroadcastBitStackChanged |
1545 Thread::eBroadcastBitThreadSelected );
1546
1547 listener.StartListeningForEventSpec (*this, target_event_spec);
1548 listener.StartListeningForEventSpec (*this, process_event_spec);
1549 listener.StartListeningForEventSpec (*this, thread_event_spec);
1550 listener.StartListeningForEvents (m_command_interpreter_ap.get(),
1551 CommandInterpreter::eBroadcastBitQuitCommandReceived |
1552 CommandInterpreter::eBroadcastBitAsynchronousOutputData |
1553 CommandInterpreter::eBroadcastBitAsynchronousErrorData );
1554
1555 // Let the thread that spawned us know that we have started up and
1556 // that we are now listening to all required events so no events get missed
1557 m_sync_broadcaster.BroadcastEvent(eBroadcastBitEventThreadIsListening);
1558
1559 bool done = false;
1560 while (!done)
1561 {
1562 EventSP event_sp;
1563 if (listener.WaitForEvent(NULL, event_sp))
1564 {
1565 if (event_sp)
1566 {
1567 Broadcaster *broadcaster = event_sp->GetBroadcaster();
1568 if (broadcaster)
1569 {
1570 uint32_t event_type = event_sp->GetType();
1571 ConstString broadcaster_class (broadcaster->GetBroadcasterClass());
1572 if (broadcaster_class == broadcaster_class_process)
1573 {
1574 HandleProcessEvent (event_sp);
1575 }
1576 else if (broadcaster_class == broadcaster_class_target)
1577 {
1578 if (Breakpoint::BreakpointEventData::GetEventDataFromEvent(event_sp.get()))
1579 {
1580 HandleBreakpointEvent (event_sp);
1581 }
1582 }
1583 else if (broadcaster_class == broadcaster_class_thread)
1584 {
1585 HandleThreadEvent (event_sp);
1586 }
1587 else if (broadcaster == m_command_interpreter_ap.get())
1588 {
1589 if (event_type & CommandInterpreter::eBroadcastBitQuitCommandReceived)
1590 {
1591 done = true;
1592 }
1593 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousErrorData)
1594 {
1595 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get()));
1596 if (data && data[0])
1597 {
1598 StreamSP error_sp (GetAsyncErrorStream());
1599 if (error_sp)
1600 {
1601 error_sp->PutCString(data);
1602 error_sp->Flush();
1603 }
1604 }
1605 }
1606 else if (event_type & CommandInterpreter::eBroadcastBitAsynchronousOutputData)
1607 {
1608 const char *data = reinterpret_cast<const char *>(EventDataBytes::GetBytesFromEvent (event_sp.get()));
1609 if (data && data[0])
1610 {
1611 StreamSP output_sp (GetAsyncOutputStream());
1612 if (output_sp)
1613 {
1614 output_sp->PutCString(data);
1615 output_sp->Flush();
1616 }
1617 }
1618 }
1619 }
1620 }
1621
1622 if (m_forward_listener_sp)
1623 m_forward_listener_sp->AddEvent(event_sp);
1624 }
1625 }
1626 }
1627 }
1628
1629 lldb::thread_result_t
EventHandlerThread(lldb::thread_arg_t arg)1630 Debugger::EventHandlerThread (lldb::thread_arg_t arg)
1631 {
1632 ((Debugger *)arg)->DefaultEventHandler();
1633 return NULL;
1634 }
1635
1636 bool
StartEventHandlerThread()1637 Debugger::StartEventHandlerThread()
1638 {
1639 if (!m_event_handler_thread.IsJoinable())
1640 {
1641 // We must synchronize with the DefaultEventHandler() thread to ensure
1642 // it is up and running and listening to events before we return from
1643 // this function. We do this by listening to events for the
1644 // eBroadcastBitEventThreadIsListening from the m_sync_broadcaster
1645 Listener listener("lldb.debugger.event-handler");
1646 listener.StartListeningForEvents(&m_sync_broadcaster, eBroadcastBitEventThreadIsListening);
1647
1648 // Use larger 8MB stack for this thread
1649 m_event_handler_thread = ThreadLauncher::LaunchThread("lldb.debugger.event-handler", EventHandlerThread,
1650 this,
1651 NULL,
1652 g_debugger_event_thread_stack_bytes);
1653
1654 // Make sure DefaultEventHandler() is running and listening to events before we return
1655 // from this function. We are only listening for events of type
1656 // eBroadcastBitEventThreadIsListening so we don't need to check the event, we just need
1657 // to wait an infinite amount of time for it (NULL timeout as the first parameter)
1658 lldb::EventSP event_sp;
1659 listener.WaitForEvent(NULL, event_sp);
1660 }
1661 return m_event_handler_thread.IsJoinable();
1662 }
1663
1664 void
StopEventHandlerThread()1665 Debugger::StopEventHandlerThread()
1666 {
1667 if (m_event_handler_thread.IsJoinable())
1668 {
1669 GetCommandInterpreter().BroadcastEvent(CommandInterpreter::eBroadcastBitQuitCommandReceived);
1670 m_event_handler_thread.Join(nullptr);
1671 }
1672 }
1673
1674
1675 lldb::thread_result_t
IOHandlerThread(lldb::thread_arg_t arg)1676 Debugger::IOHandlerThread (lldb::thread_arg_t arg)
1677 {
1678 Debugger *debugger = (Debugger *)arg;
1679 debugger->ExecuteIOHandlers();
1680 debugger->StopEventHandlerThread();
1681 return NULL;
1682 }
1683
1684 bool
StartIOHandlerThread()1685 Debugger::StartIOHandlerThread()
1686 {
1687 if (!m_io_handler_thread.IsJoinable())
1688 m_io_handler_thread = ThreadLauncher::LaunchThread ("lldb.debugger.io-handler",
1689 IOHandlerThread,
1690 this,
1691 NULL,
1692 8*1024*1024); // Use larger 8MB stack for this thread
1693 return m_io_handler_thread.IsJoinable();
1694 }
1695
1696 void
StopIOHandlerThread()1697 Debugger::StopIOHandlerThread()
1698 {
1699 if (m_io_handler_thread.IsJoinable())
1700 {
1701 if (m_input_file_sp)
1702 m_input_file_sp->GetFile().Close();
1703 m_io_handler_thread.Join(nullptr);
1704 }
1705 }
1706
1707 Target *
GetDummyTarget()1708 Debugger::GetDummyTarget()
1709 {
1710 return m_target_list.GetDummyTarget (*this).get();
1711 }
1712
1713 Target *
GetSelectedOrDummyTarget(bool prefer_dummy)1714 Debugger::GetSelectedOrDummyTarget(bool prefer_dummy)
1715 {
1716 Target *target = nullptr;
1717 if (!prefer_dummy)
1718 {
1719 target = m_target_list.GetSelectedTarget().get();
1720 if (target)
1721 return target;
1722 }
1723
1724 return GetDummyTarget();
1725 }
1726
1727