1 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
12 // Other libraries and framework includes
14 #include "lldb/Target/Target.h"
15 #include "lldb/Breakpoint/BreakpointResolver.h"
16 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
17 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
18 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
19 #include "lldb/Breakpoint/BreakpointResolverName.h"
20 #include "lldb/Breakpoint/Watchpoint.h"
21 #include "lldb/Core/Debugger.h"
22 #include "lldb/Core/Event.h"
23 #include "lldb/Core/Log.h"
24 #include "lldb/Core/Module.h"
25 #include "lldb/Core/ModuleSpec.h"
26 #include "lldb/Core/Section.h"
27 #include "lldb/Core/SourceManager.h"
28 #include "lldb/Core/State.h"
29 #include "lldb/Core/StreamFile.h"
30 #include "lldb/Core/StreamString.h"
31 #include "lldb/Core/Timer.h"
32 #include "lldb/Core/ValueObject.h"
33 #include "lldb/Expression/REPL.h"
34 #include "lldb/Expression/UserExpression.h"
35 #include "Plugins/ExpressionParser/Clang/ClangASTSource.h"
36 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
37 #include "Plugins/ExpressionParser/Clang/ClangModulesDeclVendor.h"
38 #include "lldb/Host/FileSpec.h"
39 #include "lldb/Host/Host.h"
40 #include "lldb/Interpreter/CommandInterpreter.h"
41 #include "lldb/Interpreter/CommandReturnObject.h"
42 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
43 #include "lldb/Interpreter/OptionValues.h"
44 #include "lldb/Interpreter/Property.h"
45 #include "lldb/Symbol/ClangASTContext.h"
46 #include "lldb/Symbol/ObjectFile.h"
47 #include "lldb/Symbol/Function.h"
48 #include "lldb/Symbol/Symbol.h"
49 #include "lldb/Target/Language.h"
50 #include "lldb/Target/LanguageRuntime.h"
51 #include "lldb/Target/ObjCLanguageRuntime.h"
52 #include "lldb/Target/Process.h"
53 #include "lldb/Target/SectionLoadList.h"
54 #include "lldb/Target/StackFrame.h"
55 #include "lldb/Target/SystemRuntime.h"
56 #include "lldb/Target/Thread.h"
57 #include "lldb/Target/ThreadSpec.h"
58 #include "lldb/Utility/LLDBAssert.h"
61 using namespace lldb_private;
64 Target::GetStaticBroadcasterClass ()
66 static ConstString class_name ("lldb.target");
70 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp, bool is_dummy_target) :
71 TargetProperties (this),
72 Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()),
73 ExecutionContextScope (),
74 m_debugger (debugger),
75 m_platform_sp (platform_sp),
76 m_mutex (Mutex::eMutexTypeRecursive),
79 m_section_load_history (),
80 m_breakpoint_list (false),
81 m_internal_breakpoint_list (true),
84 m_search_filter_sp (),
85 m_image_search_paths (ImageSearchPathsChanged, this),
87 m_source_manager_ap(),
89 m_stop_hook_next_id (0),
91 m_suppress_stop_hooks (false),
92 m_is_dummy_target(is_dummy_target)
95 SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed");
96 SetEventName (eBroadcastBitModulesLoaded, "modules-loaded");
97 SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded");
98 SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed");
99 SetEventName (eBroadcastBitSymbolsLoaded, "symbols-loaded");
101 CheckInWithManager();
103 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
105 log->Printf ("%p Target::Target()", static_cast<void*>(this));
106 if (m_arch.IsValid())
108 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
114 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
116 log->Printf ("%p Target::~Target()", static_cast<void*>(this));
117 DeleteCurrentProcess ();
121 Target::PrimeFromDummyTarget(Target *target)
126 m_stop_hooks = target->m_stop_hooks;
128 for (BreakpointSP breakpoint_sp : target->m_breakpoint_list.Breakpoints())
130 if (breakpoint_sp->IsInternal())
133 BreakpointSP new_bp (new Breakpoint (*this, *breakpoint_sp.get()));
134 AddBreakpoint (new_bp, false);
139 Target::Dump (Stream *s, lldb::DescriptionLevel description_level)
141 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
142 if (description_level != lldb::eDescriptionLevelBrief)
145 s->PutCString("Target\n");
148 m_breakpoint_list.Dump(s);
149 m_internal_breakpoint_list.Dump(s);
154 Module *exe_module = GetExecutableModulePointer();
156 s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString());
158 s->PutCString ("No executable module.");
163 Target::CleanupProcess ()
165 // Do any cleanup of the target we need to do between process instances.
166 // NB It is better to do this before destroying the process in case the
167 // clean up needs some help from the process.
168 m_breakpoint_list.ClearAllBreakpointSites();
169 m_internal_breakpoint_list.ClearAllBreakpointSites();
170 // Disable watchpoints just on the debugger side.
171 Mutex::Locker locker;
172 this->GetWatchpointList().GetListMutex(locker);
173 DisableAllWatchpoints(false);
174 ClearAllWatchpointHitCounts();
175 ClearAllWatchpointHistoricValues();
179 Target::DeleteCurrentProcess ()
183 m_section_load_history.Clear();
184 if (m_process_sp->IsAlive())
185 m_process_sp->Destroy(false);
187 m_process_sp->Finalize();
191 m_process_sp.reset();
195 const lldb::ProcessSP &
196 Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file)
198 DeleteCurrentProcess ();
199 m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name, listener, crash_file);
203 const lldb::ProcessSP &
204 Target::GetProcessSP () const
210 Target::GetREPL (Error &err, lldb::LanguageType language, const char *repl_options, bool can_create)
212 if (language == eLanguageTypeUnknown)
214 std::set<LanguageType> repl_languages;
216 Language::GetLanguagesSupportingREPLs(repl_languages);
218 if (repl_languages.size() == 1)
220 language = *repl_languages.begin();
222 else if (repl_languages.size() == 0)
224 err.SetErrorStringWithFormat("LLDB isn't configured with support support for any REPLs.");
229 err.SetErrorStringWithFormat("Multiple possible REPL languages. Please specify a language.");
234 REPLMap::iterator pos = m_repl_map.find(language);
236 if (pos != m_repl_map.end())
243 err.SetErrorStringWithFormat("Couldn't find an existing REPL for %s, and can't create a new one", Language::GetNameForLanguageType(language));
244 return lldb::REPLSP();
247 Debugger *const debugger = nullptr;
248 lldb::REPLSP ret = REPL::Create(err, language, debugger, this, repl_options);
252 m_repl_map[language] = ret;
253 return m_repl_map[language];
258 err.SetErrorStringWithFormat("Couldn't create a REPL for %s", Language::GetNameForLanguageType(language));
261 return lldb::REPLSP();
265 Target::SetREPL (lldb::LanguageType language, lldb::REPLSP repl_sp)
267 lldbassert(!m_repl_map.count(language));
269 m_repl_map[language] = repl_sp;
275 Mutex::Locker locker (m_mutex);
277 DeleteCurrentProcess ();
278 m_platform_sp.reset();
281 m_section_load_history.Clear();
282 const bool notify = false;
283 m_breakpoint_list.RemoveAll(notify);
284 m_internal_breakpoint_list.RemoveAll(notify);
285 m_last_created_breakpoint.reset();
286 m_last_created_watchpoint.reset();
287 m_search_filter_sp.reset();
288 m_image_search_paths.Clear(notify);
289 m_stop_hooks.clear();
290 m_stop_hook_next_id = 0;
291 m_suppress_stop_hooks = false;
295 Target::GetBreakpointList(bool internal)
298 return m_internal_breakpoint_list;
300 return m_breakpoint_list;
303 const BreakpointList &
304 Target::GetBreakpointList(bool internal) const
307 return m_internal_breakpoint_list;
309 return m_breakpoint_list;
313 Target::GetBreakpointByID (break_id_t break_id)
317 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
318 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
320 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
326 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
327 const FileSpecList *source_file_spec_list,
328 RegularExpression &source_regex,
331 LazyBool move_to_nearest_code)
333 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list));
334 if (move_to_nearest_code == eLazyBoolCalculate)
335 move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
336 BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex(nullptr, source_regex, !static_cast<bool>(move_to_nearest_code)));
337 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
341 Target::CreateBreakpoint (const FileSpecList *containingModules,
342 const FileSpec &file,
344 LazyBool check_inlines,
345 LazyBool skip_prologue,
348 LazyBool move_to_nearest_code)
350 if (check_inlines == eLazyBoolCalculate)
352 const InlineStrategy inline_strategy = GetInlineStrategy();
353 switch (inline_strategy)
355 case eInlineBreakpointsNever:
356 check_inlines = eLazyBoolNo;
359 case eInlineBreakpointsHeaders:
360 if (file.IsSourceImplementationFile())
361 check_inlines = eLazyBoolNo;
363 check_inlines = eLazyBoolYes;
366 case eInlineBreakpointsAlways:
367 check_inlines = eLazyBoolYes;
371 SearchFilterSP filter_sp;
372 if (check_inlines == eLazyBoolNo)
374 // Not checking for inlines, we are looking only for matching compile units
375 FileSpecList compile_unit_list;
376 compile_unit_list.Append (file);
377 filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list);
381 filter_sp = GetSearchFilterForModuleList (containingModules);
383 if (skip_prologue == eLazyBoolCalculate)
384 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
385 if (move_to_nearest_code == eLazyBoolCalculate)
386 move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
388 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine(nullptr,
393 !static_cast<bool>(move_to_nearest_code)));
394 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
398 Target::CreateBreakpoint (lldb::addr_t addr, bool internal, bool hardware)
402 // Check for any reason we want to move this breakpoint to other address.
403 addr = GetBreakableLoadAddress(addr);
405 // Attempt to resolve our load address if possible, though it is ok if
406 // it doesn't resolve to section/offset.
408 // Try and resolve as a load address if possible
409 GetSectionLoadList().ResolveLoadAddress(addr, so_addr);
410 if (!so_addr.IsValid())
412 // The address didn't resolve, so just set this as an absolute address
413 so_addr.SetOffset (addr);
415 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal, hardware));
420 Target::CreateBreakpoint (const Address &addr, bool internal, bool hardware)
422 SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this()));
423 BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, addr));
424 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, false);
428 Target::CreateAddressInModuleBreakpoint (lldb::addr_t file_addr,
430 const FileSpec *file_spec,
431 bool request_hardware)
433 SearchFilterSP filter_sp(new SearchFilterForUnconstrainedSearches (shared_from_this()));
434 BreakpointResolverSP resolver_sp(new BreakpointResolverAddress(nullptr, file_addr, file_spec));
435 return CreateBreakpoint (filter_sp, resolver_sp, internal, request_hardware, false);
439 Target::CreateBreakpoint (const FileSpecList *containingModules,
440 const FileSpecList *containingSourceFiles,
441 const char *func_name,
442 uint32_t func_name_type_mask,
443 LanguageType language,
444 LazyBool skip_prologue,
451 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
453 if (skip_prologue == eLazyBoolCalculate)
454 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
455 if (language == lldb::eLanguageTypeUnknown)
456 language = GetLanguage();
458 BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
464 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
470 Target::CreateBreakpoint (const FileSpecList *containingModules,
471 const FileSpecList *containingSourceFiles,
472 const std::vector<std::string> &func_names,
473 uint32_t func_name_type_mask,
474 LanguageType language,
475 LazyBool skip_prologue,
480 size_t num_names = func_names.size();
483 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
485 if (skip_prologue == eLazyBoolCalculate)
486 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
487 if (language == lldb::eLanguageTypeUnknown)
488 language = GetLanguage();
490 BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
495 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
501 Target::CreateBreakpoint (const FileSpecList *containingModules,
502 const FileSpecList *containingSourceFiles,
503 const char *func_names[],
505 uint32_t func_name_type_mask,
506 LanguageType language,
507 LazyBool skip_prologue,
514 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
516 if (skip_prologue == eLazyBoolCalculate)
517 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
518 if (language == lldb::eLanguageTypeUnknown)
519 language = GetLanguage();
521 BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
527 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
533 Target::GetSearchFilterForModule (const FileSpec *containingModule)
535 SearchFilterSP filter_sp;
536 if (containingModule != nullptr)
538 // TODO: We should look into sharing module based search filters
539 // across many breakpoints like we do for the simple target based one
540 filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule));
544 if (!m_search_filter_sp)
545 m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this()));
546 filter_sp = m_search_filter_sp;
552 Target::GetSearchFilterForModuleList (const FileSpecList *containingModules)
554 SearchFilterSP filter_sp;
555 if (containingModules && containingModules->GetSize() != 0)
557 // TODO: We should look into sharing module based search filters
558 // across many breakpoints like we do for the simple target based one
559 filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules));
563 if (!m_search_filter_sp)
564 m_search_filter_sp.reset (new SearchFilterForUnconstrainedSearches (shared_from_this()));
565 filter_sp = m_search_filter_sp;
571 Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules,
572 const FileSpecList *containingSourceFiles)
574 if (containingSourceFiles == nullptr || containingSourceFiles->GetSize() == 0)
575 return GetSearchFilterForModuleList(containingModules);
577 SearchFilterSP filter_sp;
578 if (containingModules == nullptr)
580 // We could make a special "CU List only SearchFilter". Better yet was if these could be composable,
581 // but that will take a little reworking.
583 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles));
587 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles));
593 Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules,
594 const FileSpecList *containingSourceFiles,
595 RegularExpression &func_regex,
596 lldb::LanguageType requested_language,
597 LazyBool skip_prologue,
601 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
603 (skip_prologue == eLazyBoolCalculate) ? GetSkipPrologue()
604 : static_cast<bool>(skip_prologue);
605 BreakpointResolverSP resolver_sp(new BreakpointResolverName(nullptr,
610 return CreateBreakpoint (filter_sp, resolver_sp, internal, hardware, true);
614 Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal, Args *additional_args, Error *error)
616 BreakpointSP exc_bkpt_sp = LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal);
617 if (exc_bkpt_sp && additional_args)
619 Breakpoint::BreakpointPreconditionSP precondition_sp = exc_bkpt_sp->GetPrecondition();
620 if (precondition_sp && additional_args)
623 *error = precondition_sp->ConfigurePrecondition(*additional_args);
625 precondition_sp->ConfigurePrecondition(*additional_args);
632 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal, bool request_hardware, bool resolve_indirect_symbols)
635 if (filter_sp && resolver_sp)
637 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp, request_hardware, resolve_indirect_symbols));
638 resolver_sp->SetBreakpoint (bp_sp.get());
639 AddBreakpoint (bp_sp, internal);
645 Target::AddBreakpoint (lldb::BreakpointSP bp_sp, bool internal)
650 m_internal_breakpoint_list.Add (bp_sp, false);
652 m_breakpoint_list.Add (bp_sp, true);
654 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
658 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
659 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, bp_sp->IsInternal() ? "yes" : "no", s.GetData());
662 bp_sp->ResolveBreakpoint();
666 m_last_created_breakpoint = bp_sp;
671 Target::ProcessIsValid()
673 return (m_process_sp && m_process_sp->IsAlive());
677 CheckIfWatchpointsExhausted(Target *target, Error &error)
679 uint32_t num_supported_hardware_watchpoints;
680 Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints);
683 uint32_t num_current_watchpoints = target->GetWatchpointList().GetSize();
684 if (num_current_watchpoints >= num_supported_hardware_watchpoints)
685 error.SetErrorStringWithFormat("number of supported hardware watchpoints (%u) has been reached",
686 num_supported_hardware_watchpoints);
691 // See also Watchpoint::SetWatchpointType(uint32_t type) and
692 // the OptionGroupWatchpoint::WatchType enum type.
694 Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const CompilerType *type, uint32_t kind, Error &error)
696 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
698 log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n",
699 __FUNCTION__, addr, (uint64_t)size, kind);
702 if (!ProcessIsValid())
704 error.SetErrorString("process is not alive");
708 if (addr == LLDB_INVALID_ADDRESS || size == 0)
711 error.SetErrorString("cannot set a watchpoint with watch_size of 0");
713 error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr);
717 if (!LLDB_WATCH_TYPE_IS_VALID(kind))
719 error.SetErrorStringWithFormat ("invalid watchpoint type: %d", kind);
722 // Currently we only support one watchpoint per address, with total number
723 // of watchpoints limited by the hardware which the inferior is running on.
725 // Grab the list mutex while doing operations.
726 const bool notify = false; // Don't notify about all the state changes we do on creating the watchpoint.
727 Mutex::Locker locker;
728 this->GetWatchpointList().GetListMutex(locker);
729 WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr);
732 size_t old_size = matched_sp->GetByteSize();
734 (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) |
735 (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0);
736 // Return the existing watchpoint if both size and type match.
737 if (size == old_size && kind == old_type)
740 wp_sp->SetEnabled(false, notify);
744 // Nil the matched watchpoint; we will be creating a new one.
745 m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
746 m_watchpoint_list.Remove(matched_sp->GetID(), true);
752 wp_sp.reset(new Watchpoint(*this, addr, size, type));
753 wp_sp->SetWatchpointType(kind, notify);
754 m_watchpoint_list.Add (wp_sp, true);
757 error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
759 log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n",
761 error.Success() ? "succeeded" : "failed",
766 // Enabling the watchpoint on the device side failed.
767 // Remove the said watchpoint from the list maintained by the target instance.
768 m_watchpoint_list.Remove (wp_sp->GetID(), true);
769 // See if we could provide more helpful error message.
770 if (!CheckIfWatchpointsExhausted(this, error))
772 if (!OptionGroupWatchpoint::IsWatchSizeSupported(size))
773 error.SetErrorStringWithFormat("watch size of %" PRIu64 " is not supported", (uint64_t)size);
778 m_last_created_watchpoint = wp_sp;
783 Target::RemoveAllBreakpoints (bool internal_also)
785 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
787 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
789 m_breakpoint_list.RemoveAll (true);
791 m_internal_breakpoint_list.RemoveAll (false);
793 m_last_created_breakpoint.reset();
797 Target::DisableAllBreakpoints (bool internal_also)
799 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
801 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
803 m_breakpoint_list.SetEnabledAll (false);
805 m_internal_breakpoint_list.SetEnabledAll (false);
809 Target::EnableAllBreakpoints (bool internal_also)
811 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
813 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
815 m_breakpoint_list.SetEnabledAll (true);
817 m_internal_breakpoint_list.SetEnabledAll (true);
821 Target::RemoveBreakpointByID (break_id_t break_id)
823 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
825 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
827 if (DisableBreakpointByID (break_id))
829 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
830 m_internal_breakpoint_list.Remove(break_id, false);
833 if (m_last_created_breakpoint)
835 if (m_last_created_breakpoint->GetID() == break_id)
836 m_last_created_breakpoint.reset();
838 m_breakpoint_list.Remove(break_id, true);
846 Target::DisableBreakpointByID (break_id_t break_id)
848 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
850 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
854 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
855 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
857 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
860 bp_sp->SetEnabled (false);
867 Target::EnableBreakpointByID (break_id_t break_id)
869 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
871 log->Printf ("Target::%s (break_id = %i, internal = %s)\n",
874 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
878 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
879 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
881 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
885 bp_sp->SetEnabled (true);
891 // The flag 'end_to_end', default to true, signifies that the operation is
892 // performed end to end, for both the debugger and the debuggee.
894 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
895 // to end operations.
897 Target::RemoveAllWatchpoints (bool end_to_end)
899 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
901 log->Printf ("Target::%s\n", __FUNCTION__);
904 m_watchpoint_list.RemoveAll(true);
908 // Otherwise, it's an end to end operation.
910 if (!ProcessIsValid())
913 size_t num_watchpoints = m_watchpoint_list.GetSize();
914 for (size_t i = 0; i < num_watchpoints; ++i)
916 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
920 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
924 m_watchpoint_list.RemoveAll (true);
925 m_last_created_watchpoint.reset();
926 return true; // Success!
929 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
932 Target::DisableAllWatchpoints (bool end_to_end)
934 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
936 log->Printf ("Target::%s\n", __FUNCTION__);
939 m_watchpoint_list.SetEnabledAll(false);
943 // Otherwise, it's an end to end operation.
945 if (!ProcessIsValid())
948 size_t num_watchpoints = m_watchpoint_list.GetSize();
949 for (size_t i = 0; i < num_watchpoints; ++i)
951 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
955 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
959 return true; // Success!
962 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
965 Target::EnableAllWatchpoints (bool end_to_end)
967 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
969 log->Printf ("Target::%s\n", __FUNCTION__);
972 m_watchpoint_list.SetEnabledAll(true);
976 // Otherwise, it's an end to end operation.
978 if (!ProcessIsValid())
981 size_t num_watchpoints = m_watchpoint_list.GetSize();
982 for (size_t i = 0; i < num_watchpoints; ++i)
984 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
988 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
992 return true; // Success!
995 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
997 Target::ClearAllWatchpointHitCounts ()
999 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1001 log->Printf ("Target::%s\n", __FUNCTION__);
1003 size_t num_watchpoints = m_watchpoint_list.GetSize();
1004 for (size_t i = 0; i < num_watchpoints; ++i)
1006 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1010 wp_sp->ResetHitCount();
1012 return true; // Success!
1015 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1017 Target::ClearAllWatchpointHistoricValues ()
1019 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1021 log->Printf ("Target::%s\n", __FUNCTION__);
1023 size_t num_watchpoints = m_watchpoint_list.GetSize();
1024 for (size_t i = 0; i < num_watchpoints; ++i)
1026 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1030 wp_sp->ResetHistoricValues();
1032 return true; // Success!
1035 // Assumption: Caller holds the list mutex lock for m_watchpoint_list
1036 // during these operations.
1038 Target::IgnoreAllWatchpoints (uint32_t ignore_count)
1040 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1042 log->Printf ("Target::%s\n", __FUNCTION__);
1044 if (!ProcessIsValid())
1047 size_t num_watchpoints = m_watchpoint_list.GetSize();
1048 for (size_t i = 0; i < num_watchpoints; ++i)
1050 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1054 wp_sp->SetIgnoreCount(ignore_count);
1056 return true; // Success!
1059 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1061 Target::DisableWatchpointByID (lldb::watch_id_t watch_id)
1063 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1065 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1067 if (!ProcessIsValid())
1070 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1073 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
1077 // Else, fallthrough.
1082 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1084 Target::EnableWatchpointByID (lldb::watch_id_t watch_id)
1086 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1088 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1090 if (!ProcessIsValid())
1093 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1096 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
1100 // Else, fallthrough.
1105 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1107 Target::RemoveWatchpointByID (lldb::watch_id_t watch_id)
1109 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1111 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1113 WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id);
1114 if (watch_to_remove_sp == m_last_created_watchpoint)
1115 m_last_created_watchpoint.reset();
1117 if (DisableWatchpointByID (watch_id))
1119 m_watchpoint_list.Remove(watch_id, true);
1125 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1127 Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count)
1129 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
1131 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1133 if (!ProcessIsValid())
1136 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
1139 wp_sp->SetIgnoreCount(ignore_count);
1146 Target::GetExecutableModule ()
1148 // search for the first executable in the module list
1149 for (size_t i = 0; i < m_images.GetSize(); ++i)
1151 ModuleSP module_sp = m_images.GetModuleAtIndex (i);
1152 lldb_private::ObjectFile * obj = module_sp->GetObjectFile();
1155 if (obj->GetType() == ObjectFile::Type::eTypeExecutable)
1158 // as fall back return the first module loaded
1159 return m_images.GetModuleAtIndex (0);
1163 Target::GetExecutableModulePointer ()
1165 return GetExecutableModule().get();
1169 LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target)
1172 StreamString feedback_stream;
1173 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error, &feedback_stream))
1175 if (error.AsCString())
1176 target->GetDebugger().GetErrorFile()->Printf("unable to load scripting data for module %s - error reported was %s\n",
1177 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1180 if (feedback_stream.GetSize())
1181 target->GetDebugger().GetErrorFile()->Printf("%s\n",
1182 feedback_stream.GetData());
1186 Target::ClearModules(bool delete_locations)
1188 ModulesDidUnload (m_images, delete_locations);
1189 m_section_load_history.Clear();
1191 m_scratch_type_system_map.Clear();
1192 m_ast_importer_sp.reset();
1198 // When a process exec's we need to know about it so we can do some cleanup.
1199 m_breakpoint_list.RemoveInvalidLocations(m_arch);
1200 m_internal_breakpoint_list.RemoveInvalidLocations(m_arch);
1204 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files)
1206 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1207 ClearModules(false);
1211 Timer scoped_timer (__PRETTY_FUNCTION__,
1212 "Target::SetExecutableModule (executable = '%s')",
1213 executable_sp->GetFileSpec().GetPath().c_str());
1215 m_images.Append(executable_sp); // The first image is our executable file
1217 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module.
1218 if (!m_arch.IsValid())
1220 m_arch = executable_sp->GetArchitecture();
1222 log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
1225 FileSpecList dependent_files;
1226 ObjectFile *executable_objfile = executable_sp->GetObjectFile();
1228 if (executable_objfile && get_dependent_files)
1230 executable_objfile->GetDependentModules(dependent_files);
1231 for (uint32_t i=0; i<dependent_files.GetSize(); i++)
1233 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i));
1234 FileSpec platform_dependent_file_spec;
1236 m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr, platform_dependent_file_spec);
1238 platform_dependent_file_spec = dependent_file_spec;
1240 ModuleSpec module_spec (platform_dependent_file_spec, m_arch);
1241 ModuleSP image_module_sp(GetSharedModule (module_spec));
1242 if (image_module_sp)
1244 ObjectFile *objfile = image_module_sp->GetObjectFile();
1246 objfile->GetDependentModules(dependent_files);
1254 Target::SetArchitecture (const ArchSpec &arch_spec)
1256 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1257 bool missing_local_arch = !m_arch.IsValid();
1258 bool replace_local_arch = true;
1259 bool compatible_local_arch = false;
1260 ArchSpec other(arch_spec);
1262 if (!missing_local_arch)
1264 if (m_arch.IsCompatibleMatch(arch_spec))
1266 other.MergeFrom(m_arch);
1268 if (m_arch.IsCompatibleMatch(other))
1270 compatible_local_arch = true;
1271 bool arch_changed, vendor_changed, os_changed, os_ver_changed, env_changed;
1273 m_arch.PiecewiseTripleCompare(other,
1280 if (!arch_changed && !vendor_changed && !os_changed)
1281 replace_local_arch = false;
1286 if (compatible_local_arch || missing_local_arch)
1288 // If we haven't got a valid arch spec, or the architectures are compatible
1289 // update the architecture, unless the one we already have is more specified
1290 if (replace_local_arch)
1293 log->Printf ("Target::SetArchitecture set architecture to %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
1297 // If we have an executable file, try to reset the executable to the desired architecture
1299 log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1301 ModuleSP executable_sp = GetExecutableModule ();
1304 // Need to do something about unsetting breakpoints.
1309 log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1310 ModuleSpec module_spec (executable_sp->GetFileSpec(), other);
1311 Error error = ModuleList::GetSharedModule(module_spec,
1313 &GetExecutableSearchPaths(),
1317 if (!error.Fail() && executable_sp)
1319 SetExecutableModule (executable_sp, true);
1327 Target::MergeArchitecture (const ArchSpec &arch_spec)
1329 if (arch_spec.IsValid())
1331 if (m_arch.IsCompatibleMatch(arch_spec))
1333 // The current target arch is compatible with "arch_spec", see if we
1334 // can improve our current architecture using bits from "arch_spec"
1336 // Merge bits from arch_spec into "merged_arch" and set our architecture
1337 ArchSpec merged_arch (m_arch);
1338 merged_arch.MergeFrom (arch_spec);
1339 return SetArchitecture(merged_arch);
1343 // The new architecture is different, we just need to replace it
1344 return SetArchitecture(arch_spec);
1351 Target::WillClearList (const ModuleList& module_list)
1356 Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp)
1358 // A module is being added to this target for the first time
1361 ModuleList my_module_list;
1362 my_module_list.Append(module_sp);
1363 LoadScriptingResourceForModule(module_sp, this);
1364 ModulesDidLoad (my_module_list);
1369 Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp)
1371 // A module is being removed from this target.
1374 ModuleList my_module_list;
1375 my_module_list.Append(module_sp);
1376 ModulesDidUnload (my_module_list, false);
1381 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
1383 // A module is replacing an already added module
1386 m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
1387 m_internal_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
1392 Target::ModulesDidLoad (ModuleList &module_list)
1394 if (m_valid && module_list.GetSize())
1396 m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1397 m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1400 m_process_sp->ModulesDidLoad (module_list);
1402 BroadcastEvent (eBroadcastBitModulesLoaded, new TargetEventData (this->shared_from_this(), module_list));
1407 Target::SymbolsDidLoad (ModuleList &module_list)
1409 if (m_valid && module_list.GetSize())
1413 LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
1416 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime;
1417 objc_runtime->SymbolsDidLoad(module_list);
1421 m_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1422 m_internal_breakpoint_list.UpdateBreakpoints (module_list, true, false);
1423 BroadcastEvent (eBroadcastBitSymbolsLoaded, new TargetEventData (this->shared_from_this(), module_list));
1428 Target::ModulesDidUnload (ModuleList &module_list, bool delete_locations)
1430 if (m_valid && module_list.GetSize())
1432 UnloadModuleSections (module_list);
1433 m_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations);
1434 m_internal_breakpoint_list.UpdateBreakpoints (module_list, false, delete_locations);
1435 BroadcastEvent (eBroadcastBitModulesUnloaded, new TargetEventData (this->shared_from_this(), module_list));
1440 Target::ModuleIsExcludedForUnconstrainedSearches (const FileSpec &module_file_spec)
1442 if (GetBreakpointsConsultPlatformAvoidList())
1444 ModuleList matchingModules;
1445 ModuleSpec module_spec (module_file_spec);
1446 size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
1448 // If there is more than one module for this file spec, only return true if ALL the modules are on the
1450 if (num_modules > 0)
1452 for (size_t i = 0; i < num_modules; i++)
1454 if (!ModuleIsExcludedForUnconstrainedSearches (matchingModules.GetModuleAtIndex(i)))
1464 Target::ModuleIsExcludedForUnconstrainedSearches (const lldb::ModuleSP &module_sp)
1466 if (GetBreakpointsConsultPlatformAvoidList())
1469 return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches (*this, module_sp);
1475 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error)
1477 SectionSP section_sp (addr.GetSection());
1480 // If the contents of this section are encrypted, the on-disk file is unusable. Read only from live memory.
1481 if (section_sp->IsEncrypted())
1483 error.SetErrorString("section is encrypted");
1486 ModuleSP module_sp (section_sp->GetModule());
1489 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
1492 size_t bytes_read = objfile->ReadSectionData (section_sp.get(),
1499 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString());
1502 error.SetErrorString("address isn't from a object file");
1505 error.SetErrorString("address isn't in a module");
1508 error.SetErrorString("address doesn't contain a section that points to a section in a object file");
1514 Target::ReadMemory (const Address& addr,
1515 bool prefer_file_cache,
1519 lldb::addr_t *load_addr_ptr)
1523 // if we end up reading this from process memory, we will fill this
1524 // with the actual load address
1526 *load_addr_ptr = LLDB_INVALID_ADDRESS;
1528 size_t bytes_read = 0;
1530 addr_t load_addr = LLDB_INVALID_ADDRESS;
1531 addr_t file_addr = LLDB_INVALID_ADDRESS;
1532 Address resolved_addr;
1533 if (!addr.IsSectionOffset())
1535 SectionLoadList §ion_load_list = GetSectionLoadList();
1536 if (section_load_list.IsEmpty())
1538 // No sections are loaded, so we must assume we are not running
1539 // yet and anything we are given is a file address.
1540 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address
1541 m_images.ResolveFileAddress (file_addr, resolved_addr);
1545 // We have at least one section loaded. This can be because
1546 // we have manually loaded some sections with "target modules load ..."
1547 // or because we have have a live process that has sections loaded
1548 // through the dynamic loader
1549 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address
1550 section_load_list.ResolveLoadAddress (load_addr, resolved_addr);
1553 if (!resolved_addr.IsValid())
1554 resolved_addr = addr;
1556 if (prefer_file_cache)
1558 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1563 if (ProcessIsValid())
1565 if (load_addr == LLDB_INVALID_ADDRESS)
1566 load_addr = resolved_addr.GetLoadAddress (this);
1568 if (load_addr == LLDB_INVALID_ADDRESS)
1570 ModuleSP addr_module_sp (resolved_addr.GetModule());
1571 if (addr_module_sp && addr_module_sp->GetFileSpec())
1572 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded",
1573 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknown>"),
1574 resolved_addr.GetFileAddress(),
1575 addr_module_sp->GetFileSpec().GetFilename().AsCString("<Unknonw>"));
1577 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress());
1581 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error);
1582 if (bytes_read != dst_len)
1584 if (error.Success())
1586 if (bytes_read == 0)
1587 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr);
1589 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
1595 *load_addr_ptr = load_addr;
1598 // If the address is not section offset we have an address that
1599 // doesn't resolve to any address in any currently loaded shared
1600 // libraries and we failed to read memory so there isn't anything
1601 // more we can do. If it is section offset, we might be able to
1602 // read cached memory from the object file.
1603 if (!resolved_addr.IsSectionOffset())
1608 if (!prefer_file_cache && resolved_addr.IsSectionOffset())
1610 // If we didn't already try and read from the object file cache, then
1611 // try it after failing to read from the process.
1612 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1618 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error)
1622 addr_t curr_addr = addr.GetLoadAddress(this);
1623 Address address(addr);
1626 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error);
1629 out_str.append(buf, length);
1630 // If we got "length - 1" bytes, we didn't get the whole C string, we
1631 // need to read some more characters
1632 if (length == sizeof(buf) - 1)
1633 curr_addr += length;
1636 address = Address(curr_addr);
1638 return out_str.size();
1642 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error)
1644 size_t total_cstr_len = 0;
1645 if (dst && dst_max_len)
1647 result_error.Clear();
1648 // NULL out everything just to be safe
1649 memset (dst, 0, dst_max_len);
1651 addr_t curr_addr = addr.GetLoadAddress(this);
1652 Address address(addr);
1654 // We could call m_process_sp->GetMemoryCacheLineSize() but I don't
1655 // think this really needs to be tied to the memory cache subsystem's
1656 // cache line size, so leave this as a fixed constant.
1657 const size_t cache_line_size = 512;
1659 size_t bytes_left = dst_max_len - 1;
1660 char *curr_dst = dst;
1662 while (bytes_left > 0)
1664 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
1665 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
1666 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error);
1668 if (bytes_read == 0)
1670 result_error = error;
1671 dst[total_cstr_len] = '\0';
1674 const size_t len = strlen(curr_dst);
1676 total_cstr_len += len;
1678 if (len < bytes_to_read)
1681 curr_dst += bytes_read;
1682 curr_addr += bytes_read;
1683 bytes_left -= bytes_read;
1684 address = Address(curr_addr);
1690 result_error.SetErrorString("invalid arguments");
1692 result_error.Clear();
1694 return total_cstr_len;
1698 Target::ReadScalarIntegerFromMemory (const Address& addr,
1699 bool prefer_file_cache,
1707 if (byte_size <= sizeof(uval))
1709 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error);
1710 if (bytes_read == byte_size)
1712 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize());
1713 lldb::offset_t offset = 0;
1715 scalar = data.GetMaxU32 (&offset, byte_size);
1717 scalar = data.GetMaxU64 (&offset, byte_size);
1720 scalar.SignExtend(byte_size * 8);
1726 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
1732 Target::ReadUnsignedIntegerFromMemory (const Address& addr,
1733 bool prefer_file_cache,
1734 size_t integer_byte_size,
1735 uint64_t fail_value,
1739 if (ReadScalarIntegerFromMemory (addr,
1745 return scalar.ULongLong(fail_value);
1750 Target::ReadPointerFromMemory (const Address& addr,
1751 bool prefer_file_cache,
1753 Address &pointer_addr)
1756 if (ReadScalarIntegerFromMemory (addr,
1758 m_arch.GetAddressByteSize(),
1763 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1764 if (pointer_vm_addr != LLDB_INVALID_ADDRESS)
1766 SectionLoadList §ion_load_list = GetSectionLoadList();
1767 if (section_load_list.IsEmpty())
1769 // No sections are loaded, so we must assume we are not running
1770 // yet and anything we are given is a file address.
1771 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr);
1775 // We have at least one section loaded. This can be because
1776 // we have manually loaded some sections with "target modules load ..."
1777 // or because we have have a live process that has sections loaded
1778 // through the dynamic loader
1779 section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr);
1781 // We weren't able to resolve the pointer value, so just return
1782 // an address with no section
1783 if (!pointer_addr.IsValid())
1784 pointer_addr.SetOffset (pointer_vm_addr);
1793 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr)
1799 // First see if we already have this module in our module list. If we do, then we're done, we don't need
1800 // to consult the shared modules list. But only do this if we are passed a UUID.
1802 if (module_spec.GetUUID().IsValid())
1803 module_sp = m_images.FindFirstModule(module_spec);
1807 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library
1808 bool did_create_module = false;
1810 // If there are image search path entries, try to use them first to acquire a suitable image.
1811 if (m_image_search_paths.GetSize())
1813 ModuleSpec transformed_spec (module_spec);
1814 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory()))
1816 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename();
1817 error = ModuleList::GetSharedModule (transformed_spec,
1819 &GetExecutableSearchPaths(),
1821 &did_create_module);
1827 // If we have a UUID, we can check our global shared module list in case
1828 // we already have it. If we don't have a valid UUID, then we can't since
1829 // the path in "module_spec" will be a platform path, and we will need to
1830 // let the platform find that file. For example, we could be asking for
1831 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick
1832 // the local copy of "/usr/lib/dyld" since our platform could be a remote
1833 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file
1835 if (module_spec.GetUUID().IsValid())
1837 // We have a UUID, it is OK to check the global module list...
1838 error = ModuleList::GetSharedModule (module_spec,
1840 &GetExecutableSearchPaths(),
1842 &did_create_module);
1847 // The platform is responsible for finding and caching an appropriate
1848 // module in the shared module cache.
1851 error = m_platform_sp->GetSharedModule (module_spec,
1854 &GetExecutableSearchPaths(),
1856 &did_create_module);
1860 error.SetErrorString("no platform is currently set");
1865 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent
1866 // module in the list already, and if there was, let's remove it.
1869 ObjectFile *objfile = module_sp->GetObjectFile();
1872 switch (objfile->GetType())
1874 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state
1875 case ObjectFile::eTypeExecutable: /// A normal executable
1876 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable
1877 case ObjectFile::eTypeObjectFile: /// An intermediate object file
1878 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution
1880 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information
1882 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable");
1884 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution
1886 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable");
1890 error_ptr->SetErrorString("unsupported file type, please specify an executable");
1893 // GetSharedModule is not guaranteed to find the old shared module, for instance
1894 // in the common case where you pass in the UUID, it is only going to find the one
1895 // module matching the UUID. In fact, it has no good way to know what the "old module"
1896 // relevant to this target is, since there might be many copies of a module with this file spec
1897 // in various running debug sessions, but only one of them will belong to this target.
1898 // So let's remove the UUID from the module list, and look in the target's module list.
1899 // Only do this if there is SOMETHING else in the module spec...
1902 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty())
1904 ModuleSpec module_spec_copy(module_spec.GetFileSpec());
1905 module_spec_copy.GetUUID().Clear();
1907 ModuleList found_modules;
1908 size_t num_found = m_images.FindModules (module_spec_copy, found_modules);
1911 old_module_sp = found_modules.GetModuleAtIndex(0);
1916 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32)
1918 m_images.ReplaceModule(old_module_sp, module_sp);
1919 Module *old_module_ptr = old_module_sp.get();
1920 old_module_sp.reset();
1921 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr);
1924 m_images.Append(module_sp);
1936 Target::CalculateTarget ()
1938 return shared_from_this();
1942 Target::CalculateProcess ()
1948 Target::CalculateThread ()
1954 Target::CalculateStackFrame ()
1956 return StackFrameSP();
1960 Target::CalculateExecutionContext (ExecutionContext &exe_ctx)
1963 exe_ctx.SetTargetPtr(this);
1967 Target::GetImageSearchPathList ()
1969 return m_image_search_paths;
1973 Target::ImageSearchPathsChanged(const PathMappingList &path_list,
1976 Target *target = (Target *)baton;
1977 ModuleSP exe_module_sp (target->GetExecutableModule());
1979 target->SetExecutableModule (exe_module_sp, true);
1983 Target::GetScratchTypeSystemForLanguage (Error *error, lldb::LanguageType language, bool create_on_demand)
1993 if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all assembly code
1994 || language == eLanguageTypeUnknown)
1996 std::set<lldb::LanguageType> languages_for_types;
1997 std::set<lldb::LanguageType> languages_for_expressions;
1999 Language::GetLanguagesSupportingTypeSystems(languages_for_types, languages_for_expressions);
2001 if (languages_for_expressions.count(eLanguageTypeC))
2003 language = eLanguageTypeC; // LLDB's default. Override by setting the target language.
2007 if (languages_for_expressions.empty())
2013 language = *languages_for_expressions.begin();
2018 return m_scratch_type_system_map.GetTypeSystemForLanguage(language, this, create_on_demand);
2021 PersistentExpressionState *
2022 Target::GetPersistentExpressionStateForLanguage (lldb::LanguageType language)
2024 TypeSystem *type_system = GetScratchTypeSystemForLanguage(nullptr, language, true);
2028 return type_system->GetPersistentExpressionState();
2037 Target::GetUserExpressionForLanguage(const char *expr,
2038 const char *expr_prefix,
2039 lldb::LanguageType language,
2040 Expression::ResultType desired_type,
2041 const EvaluateExpressionOptions &options,
2044 Error type_system_error;
2046 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2047 UserExpression *user_expr = nullptr;
2051 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2055 user_expr = type_system->GetUserExpression(expr, expr_prefix, language, desired_type, options);
2057 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2063 Target::GetFunctionCallerForLanguage (lldb::LanguageType language,
2064 const CompilerType &return_type,
2065 const Address& function_address,
2066 const ValueList &arg_value_list,
2070 Error type_system_error;
2071 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2072 FunctionCaller *persistent_fn = nullptr;
2076 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2077 return persistent_fn;
2080 persistent_fn = type_system->GetFunctionCaller (return_type, function_address, arg_value_list, name);
2082 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2084 return persistent_fn;
2088 Target::GetUtilityFunctionForLanguage (const char *text,
2089 lldb::LanguageType language,
2093 Error type_system_error;
2094 TypeSystem *type_system = GetScratchTypeSystemForLanguage (&type_system_error, language);
2095 UtilityFunction *utility_fn = nullptr;
2099 error.SetErrorStringWithFormat("Could not find type system for language %s: %s", Language::GetNameForLanguageType(language), type_system_error.AsCString());
2103 utility_fn = type_system->GetUtilityFunction (text, name);
2105 error.SetErrorStringWithFormat("Could not create an expression for language %s", Language::GetNameForLanguageType(language));
2111 Target::GetScratchClangASTContext(bool create_on_demand)
2115 if (TypeSystem* type_system = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC, create_on_demand))
2116 return llvm::dyn_cast<ClangASTContext>(type_system);
2122 Target::GetClangASTImporter()
2126 if (!m_ast_importer_sp)
2128 m_ast_importer_sp.reset(new ClangASTImporter());
2130 return m_ast_importer_sp;
2132 return ClangASTImporterSP();
2136 Target::SettingsInitialize ()
2138 Process::SettingsInitialize ();
2142 Target::SettingsTerminate ()
2144 Process::SettingsTerminate ();
2148 Target::GetDefaultExecutableSearchPaths ()
2150 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2152 return properties_sp->GetExecutableSearchPaths();
2153 return FileSpecList();
2157 Target::GetDefaultDebugFileSearchPaths ()
2159 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2161 return properties_sp->GetDebugFileSearchPaths();
2162 return FileSpecList();
2166 Target::GetDefaultClangModuleSearchPaths ()
2168 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2170 return properties_sp->GetClangModuleSearchPaths();
2171 return FileSpecList();
2175 Target::GetDefaultArchitecture ()
2177 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2179 return properties_sp->GetDefaultArchitecture();
2184 Target::SetDefaultArchitecture (const ArchSpec &arch)
2186 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2189 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str());
2190 return properties_sp->SetDefaultArchitecture(arch);
2195 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
2197 // The target can either exist in the "process" of ExecutionContext, or in
2198 // the "target_sp" member of SymbolContext. This accessor helper function
2199 // will get the target from one of these locations.
2201 Target *target = nullptr;
2202 if (sc_ptr != nullptr)
2203 target = sc_ptr->target_sp.get();
2204 if (target == nullptr && exe_ctx_ptr)
2205 target = exe_ctx_ptr->GetTargetPtr();
2210 Target::EvaluateExpression(const char *expr_cstr,
2211 ExecutionContextScope *exe_scope,
2212 lldb::ValueObjectSP &result_valobj_sp,
2213 const EvaluateExpressionOptions& options)
2215 result_valobj_sp.reset();
2217 ExpressionResults execution_results = eExpressionSetupError;
2219 if (expr_cstr == nullptr || expr_cstr[0] == '\0')
2220 return execution_results;
2222 // We shouldn't run stop hooks in expressions.
2223 // Be sure to reset this if you return anywhere within this function.
2224 bool old_suppress_value = m_suppress_stop_hooks;
2225 m_suppress_stop_hooks = true;
2227 ExecutionContext exe_ctx;
2231 exe_scope->CalculateExecutionContext(exe_ctx);
2233 else if (m_process_sp)
2235 m_process_sp->CalculateExecutionContext(exe_ctx);
2239 CalculateExecutionContext(exe_ctx);
2242 // Make sure we aren't just trying to see the value of a persistent
2243 // variable (something like "$0")
2244 lldb::ExpressionVariableSP persistent_var_sp;
2245 // Only check for persistent variables the expression starts with a '$'
2246 if (expr_cstr[0] == '$')
2247 persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)->GetPersistentExpressionState()->GetVariable (expr_cstr);
2249 if (persistent_var_sp)
2251 result_valobj_sp = persistent_var_sp->GetValueObject ();
2252 execution_results = eExpressionCompleted;
2256 const char *prefix = GetExpressionPrefixContentsAsCString();
2258 execution_results = UserExpression::Evaluate (exe_ctx,
2266 m_suppress_stop_hooks = old_suppress_value;
2268 return execution_results;
2271 lldb::ExpressionVariableSP
2272 Target::GetPersistentVariable(const ConstString &name)
2274 lldb::ExpressionVariableSP variable_sp;
2275 m_scratch_type_system_map.ForEach([this, name, &variable_sp](TypeSystem *type_system) -> bool
2277 if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState())
2279 variable_sp = persistent_state->GetVariable(name);
2282 return false; // Stop iterating the ForEach
2284 return true; // Keep iterating the ForEach
2290 Target::GetPersistentSymbol(const ConstString &name)
2292 lldb::addr_t address = LLDB_INVALID_ADDRESS;
2294 m_scratch_type_system_map.ForEach([this, name, &address](TypeSystem *type_system) -> bool
2296 if (PersistentExpressionState *persistent_state = type_system->GetPersistentExpressionState())
2298 address = persistent_state->LookupSymbol(name);
2299 if (address != LLDB_INVALID_ADDRESS)
2300 return false; // Stop iterating the ForEach
2302 return true; // Keep iterating the ForEach
2308 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
2310 addr_t code_addr = load_addr;
2311 switch (m_arch.GetMachine())
2313 case llvm::Triple::mips:
2314 case llvm::Triple::mipsel:
2315 case llvm::Triple::mips64:
2316 case llvm::Triple::mips64el:
2319 case eAddressClassData:
2320 case eAddressClassDebug:
2321 return LLDB_INVALID_ADDRESS;
2323 case eAddressClassUnknown:
2324 case eAddressClassInvalid:
2325 case eAddressClassCode:
2326 case eAddressClassCodeAlternateISA:
2327 case eAddressClassRuntime:
2328 if ((code_addr & 2ull) || (addr_class == eAddressClassCodeAlternateISA))
2334 case llvm::Triple::arm:
2335 case llvm::Triple::thumb:
2338 case eAddressClassData:
2339 case eAddressClassDebug:
2340 return LLDB_INVALID_ADDRESS;
2342 case eAddressClassUnknown:
2343 case eAddressClassInvalid:
2344 case eAddressClassCode:
2345 case eAddressClassCodeAlternateISA:
2346 case eAddressClassRuntime:
2347 // Check if bit zero it no set?
2348 if ((code_addr & 1ull) == 0)
2350 // Bit zero isn't set, check if the address is a multiple of 2?
2351 if (code_addr & 2ull)
2353 // The address is a multiple of 2 so it must be thumb, set bit zero
2356 else if (addr_class == eAddressClassCodeAlternateISA)
2358 // We checked the address and the address claims to be the alternate ISA
2359 // which means thumb, so set bit zero.
2374 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
2376 addr_t opcode_addr = load_addr;
2377 switch (m_arch.GetMachine())
2379 case llvm::Triple::mips:
2380 case llvm::Triple::mipsel:
2381 case llvm::Triple::mips64:
2382 case llvm::Triple::mips64el:
2383 case llvm::Triple::arm:
2384 case llvm::Triple::thumb:
2387 case eAddressClassData:
2388 case eAddressClassDebug:
2389 return LLDB_INVALID_ADDRESS;
2391 case eAddressClassInvalid:
2392 case eAddressClassUnknown:
2393 case eAddressClassCode:
2394 case eAddressClassCodeAlternateISA:
2395 case eAddressClassRuntime:
2396 opcode_addr &= ~(1ull);
2408 Target::GetBreakableLoadAddress (lldb::addr_t addr)
2410 addr_t breakable_addr = addr;
2411 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
2413 switch (m_arch.GetMachine())
2417 case llvm::Triple::mips:
2418 case llvm::Triple::mipsel:
2419 case llvm::Triple::mips64:
2420 case llvm::Triple::mips64el:
2422 addr_t function_start = 0;
2423 addr_t current_offset = 0;
2424 uint32_t loop_count = 0;
2425 Address resolved_addr;
2426 uint32_t arch_flags = m_arch.GetFlags ();
2427 bool IsMips16 = arch_flags & ArchSpec::eMIPSAse_mips16;
2428 bool IsMicromips = arch_flags & ArchSpec::eMIPSAse_micromips;
2429 SectionLoadList §ion_load_list = GetSectionLoadList();
2431 if (section_load_list.IsEmpty())
2432 // No sections are loaded, so we must assume we are not running yet
2433 // and need to operate only on file address.
2434 m_images.ResolveFileAddress (addr, resolved_addr);
2436 section_load_list.ResolveLoadAddress(addr, resolved_addr);
2438 // Get the function boundaries to make sure we don't scan back before the beginning of the current function.
2439 ModuleSP temp_addr_module_sp (resolved_addr.GetModule());
2440 if (temp_addr_module_sp)
2443 uint32_t resolve_scope = eSymbolContextFunction | eSymbolContextSymbol;
2444 temp_addr_module_sp->ResolveSymbolContextForAddress(resolved_addr, resolve_scope, sc);
2447 function_start = sc.function->GetAddressRange().GetBaseAddress().GetLoadAddress(this);
2448 if (function_start == LLDB_INVALID_ADDRESS)
2449 function_start = sc.function->GetAddressRange().GetBaseAddress().GetFileAddress();
2453 Address sym_addr = sc.symbol->GetAddress();
2454 function_start = sym_addr.GetFileAddress();
2456 current_offset = addr - function_start;
2459 // If breakpoint address is start of function then we dont have to do anything.
2460 if (current_offset == 0)
2461 return breakable_addr;
2463 loop_count = current_offset / 2;
2467 // Scan previous 6 bytes
2468 if (IsMips16 | IsMicromips)
2470 // For mips-only, instructions are always 4 bytes, so scan previous 4 bytes only.
2475 // Create Disassembler Instance
2476 lldb::DisassemblerSP disasm_sp(Disassembler::FindPlugin(m_arch, nullptr, nullptr));
2478 ExecutionContext exe_ctx;
2479 CalculateExecutionContext(exe_ctx);
2480 InstructionList instruction_list;
2481 InstructionSP prev_insn;
2482 bool prefer_file_cache = true; // Read from file
2483 uint32_t inst_to_choose = 0;
2485 for (uint32_t i = 1; i <= loop_count; i++)
2487 // Adjust the address to read from.
2488 resolved_addr.Slide (-2);
2489 AddressRange range(resolved_addr, i*2);
2490 uint32_t insn_size = 0;
2492 disasm_sp->ParseInstructions(&exe_ctx, range, nullptr, prefer_file_cache);
2494 uint32_t num_insns = disasm_sp->GetInstructionList().GetSize();
2497 prev_insn = disasm_sp->GetInstructionList().GetInstructionAtIndex(0);
2498 insn_size = prev_insn->GetOpcode().GetByteSize();
2499 if (i == 1 && insn_size == 2)
2501 // This looks like a valid 2-byte instruction (but it could be a part of upper 4 byte instruction).
2502 instruction_list.Append(prev_insn);
2507 // Here we may get one 4-byte instruction or two 2-byte instructions.
2510 // Looks like there are two 2-byte instructions above our breakpoint target address.
2511 // Now the upper 2-byte instruction is either a valid 2-byte instruction or could be a part of it's upper 4-byte instruction.
2512 // In both cases we don't care because in this case lower 2-byte instruction is definitely a valid instruction
2513 // and whatever i=1 iteration has found out is true.
2517 else if (insn_size == 4)
2519 // This instruction claims its a valid 4-byte instruction. But it could be a part of it's upper 4-byte instruction.
2520 // Lets try scanning upper 2 bytes to verify this.
2521 instruction_list.Append(prev_insn);
2528 // FIXME: We reached here that means instruction at [target - 4] has already claimed to be a 4-byte instruction,
2529 // and now instruction at [target - 6] is also claiming that it's a 4-byte instruction. This can not be true.
2530 // In this case we can not decide the valid previous instruction so we let lldb set the breakpoint at the address given by user.
2533 // This is straight-forward
2540 // Decode failed, bytes do not form a valid instruction. So whatever previous iteration has found out is true.
2543 inst_to_choose = i - 1;
2549 // Check if we are able to find any valid instruction.
2552 if (inst_to_choose > instruction_list.GetSize())
2554 prev_insn = instruction_list.GetInstructionAtIndex(inst_to_choose - 1);
2556 if (prev_insn->HasDelaySlot())
2558 uint32_t shift_size = prev_insn->GetOpcode().GetByteSize();
2559 // Adjust the breakable address
2560 breakable_addr = addr - shift_size;
2562 log->Printf ("Target::%s Breakpoint at 0x%8.8" PRIx64 " is adjusted to 0x%8.8" PRIx64 " due to delay slot\n", __FUNCTION__, addr, breakable_addr);
2568 return breakable_addr;
2572 Target::GetSourceManager ()
2574 if (!m_source_manager_ap)
2575 m_source_manager_ap.reset (new SourceManager(shared_from_this()));
2576 return *m_source_manager_ap;
2579 ClangModulesDeclVendor *
2580 Target::GetClangModulesDeclVendor ()
2582 static Mutex s_clang_modules_decl_vendor_mutex; // If this is contended we can make it per-target
2585 Mutex::Locker clang_modules_decl_vendor_locker(s_clang_modules_decl_vendor_mutex);
2587 if (!m_clang_modules_decl_vendor_ap)
2589 m_clang_modules_decl_vendor_ap.reset(ClangModulesDeclVendor::Create(*this));
2593 return m_clang_modules_decl_vendor_ap.get();
2597 Target::CreateStopHook ()
2599 lldb::user_id_t new_uid = ++m_stop_hook_next_id;
2600 Target::StopHookSP stop_hook_sp (new StopHook(shared_from_this(), new_uid));
2601 m_stop_hooks[new_uid] = stop_hook_sp;
2602 return stop_hook_sp;
2606 Target::RemoveStopHookByID (lldb::user_id_t user_id)
2608 size_t num_removed = m_stop_hooks.erase(user_id);
2609 return (num_removed != 0);
2613 Target::RemoveAllStopHooks ()
2615 m_stop_hooks.clear();
2619 Target::GetStopHookByID (lldb::user_id_t user_id)
2621 StopHookSP found_hook;
2623 StopHookCollection::iterator specified_hook_iter;
2624 specified_hook_iter = m_stop_hooks.find (user_id);
2625 if (specified_hook_iter != m_stop_hooks.end())
2626 found_hook = (*specified_hook_iter).second;
2631 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state)
2633 StopHookCollection::iterator specified_hook_iter;
2634 specified_hook_iter = m_stop_hooks.find (user_id);
2635 if (specified_hook_iter == m_stop_hooks.end())
2638 (*specified_hook_iter).second->SetIsActive (active_state);
2643 Target::SetAllStopHooksActiveState (bool active_state)
2645 StopHookCollection::iterator pos, end = m_stop_hooks.end();
2646 for (pos = m_stop_hooks.begin(); pos != end; pos++)
2648 (*pos).second->SetIsActive (active_state);
2653 Target::RunStopHooks ()
2655 if (m_suppress_stop_hooks)
2661 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression
2662 // since in that case we do not want to run the stop-hooks
2663 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
2666 if (m_stop_hooks.empty())
2669 StopHookCollection::iterator pos, end = m_stop_hooks.end();
2671 // If there aren't any active stop hooks, don't bother either:
2672 bool any_active_hooks = false;
2673 for (pos = m_stop_hooks.begin(); pos != end; pos++)
2675 if ((*pos).second->IsActive())
2677 any_active_hooks = true;
2681 if (!any_active_hooks)
2684 CommandReturnObject result;
2686 std::vector<ExecutionContext> exc_ctx_with_reasons;
2687 std::vector<SymbolContext> sym_ctx_with_reasons;
2689 ThreadList &cur_threadlist = m_process_sp->GetThreadList();
2690 size_t num_threads = cur_threadlist.GetSize();
2691 for (size_t i = 0; i < num_threads; i++)
2693 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i);
2694 if (cur_thread_sp->ThreadStoppedForAReason())
2696 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
2697 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
2698 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
2702 // If no threads stopped for a reason, don't run the stop-hooks.
2703 size_t num_exe_ctx = exc_ctx_with_reasons.size();
2704 if (num_exe_ctx == 0)
2707 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream());
2708 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream());
2710 bool keep_going = true;
2711 bool hooks_ran = false;
2712 bool print_hook_header = (m_stop_hooks.size() != 1);
2713 bool print_thread_header = (num_exe_ctx != 1);
2715 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++)
2718 StopHookSP cur_hook_sp = (*pos).second;
2719 if (!cur_hook_sp->IsActive())
2722 bool any_thread_matched = false;
2723 for (size_t i = 0; keep_going && i < num_exe_ctx; i++)
2725 if ((cur_hook_sp->GetSpecifier() == nullptr
2726 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i]))
2727 && (cur_hook_sp->GetThreadSpecifier() == nullptr
2728 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef())))
2734 if (print_hook_header && !any_thread_matched)
2736 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ?
2737 cur_hook_sp->GetCommands().GetStringAtIndex(0) :
2740 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd);
2742 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID());
2743 any_thread_matched = true;
2746 if (print_thread_header)
2747 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID());
2749 CommandInterpreterRunOptions options;
2750 options.SetStopOnContinue (true);
2751 options.SetStopOnError (true);
2752 options.SetEchoCommands (false);
2753 options.SetPrintResults (true);
2754 options.SetAddToHistory (false);
2756 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(),
2757 &exc_ctx_with_reasons[i],
2761 // If the command started the target going again, we should bag out of
2762 // running the stop hooks.
2763 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
2764 (result.GetStatus() == eReturnStatusSuccessContinuingResult))
2766 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID());
2773 result.GetImmediateOutputStream()->Flush();
2774 result.GetImmediateErrorStream()->Flush();
2777 const TargetPropertiesSP &
2778 Target::GetGlobalProperties()
2780 static TargetPropertiesSP g_settings_sp;
2783 g_settings_sp.reset(new TargetProperties(nullptr));
2785 return g_settings_sp;
2789 Target::Install (ProcessLaunchInfo *launch_info)
2792 PlatformSP platform_sp (GetPlatform());
2795 if (platform_sp->IsRemote())
2797 if (platform_sp->IsConnected())
2799 // Install all files that have an install path, and always install the
2800 // main executable when connected to a remote platform
2801 const ModuleList& modules = GetImages();
2802 const size_t num_images = modules.GetSize();
2803 for (size_t idx = 0; idx < num_images; ++idx)
2805 const bool is_main_executable = idx == 0;
2806 ModuleSP module_sp(modules.GetModuleAtIndex(idx));
2809 FileSpec local_file (module_sp->GetFileSpec());
2812 FileSpec remote_file (module_sp->GetRemoteInstallFileSpec());
2815 if (is_main_executable) // TODO: add setting for always installing main executable???
2817 // Always install the main executable
2818 remote_file = platform_sp->GetRemoteWorkingDirectory();
2819 remote_file.AppendPathComponent(module_sp->GetFileSpec().GetFilename().GetCString());
2824 error = platform_sp->Install(local_file, remote_file);
2825 if (error.Success())
2827 module_sp->SetPlatformFileSpec(remote_file);
2828 if (is_main_executable)
2830 platform_sp->SetFilePermissions(remote_file, 0700);
2832 launch_info->SetExecutableFile(remote_file, false);
2848 Target::ResolveLoadAddress (addr_t load_addr, Address &so_addr, uint32_t stop_id)
2850 return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr);
2854 Target::ResolveFileAddress (lldb::addr_t file_addr, Address &resolved_addr)
2856 return m_images.ResolveFileAddress(file_addr, resolved_addr);
2860 Target::SetSectionLoadAddress (const SectionSP §ion_sp, addr_t new_section_load_addr, bool warn_multiple)
2862 const addr_t old_section_load_addr = m_section_load_history.GetSectionLoadAddress (SectionLoadHistory::eStopIDNow, section_sp);
2863 if (old_section_load_addr != new_section_load_addr)
2865 uint32_t stop_id = 0;
2866 ProcessSP process_sp(GetProcessSP());
2868 stop_id = process_sp->GetStopID();
2870 stop_id = m_section_load_history.GetLastStopID();
2871 if (m_section_load_history.SetSectionLoadAddress (stop_id, section_sp, new_section_load_addr, warn_multiple))
2872 return true; // Return true if the section load address was changed...
2874 return false; // Return false to indicate nothing changed
2878 Target::UnloadModuleSections (const ModuleList &module_list)
2880 size_t section_unload_count = 0;
2881 size_t num_modules = module_list.GetSize();
2882 for (size_t i=0; i<num_modules; ++i)
2884 section_unload_count += UnloadModuleSections (module_list.GetModuleAtIndex(i));
2886 return section_unload_count;
2890 Target::UnloadModuleSections (const lldb::ModuleSP &module_sp)
2892 uint32_t stop_id = 0;
2893 ProcessSP process_sp(GetProcessSP());
2895 stop_id = process_sp->GetStopID();
2897 stop_id = m_section_load_history.GetLastStopID();
2898 SectionList *sections = module_sp->GetSectionList();
2899 size_t section_unload_count = 0;
2902 const uint32_t num_sections = sections->GetNumSections(0);
2903 for (uint32_t i = 0; i < num_sections; ++i)
2905 section_unload_count += m_section_load_history.SetSectionUnloaded(stop_id, sections->GetSectionAtIndex(i));
2908 return section_unload_count;
2912 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp)
2914 uint32_t stop_id = 0;
2915 ProcessSP process_sp(GetProcessSP());
2917 stop_id = process_sp->GetStopID();
2919 stop_id = m_section_load_history.GetLastStopID();
2920 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp);
2924 Target::SetSectionUnloaded (const lldb::SectionSP §ion_sp, addr_t load_addr)
2926 uint32_t stop_id = 0;
2927 ProcessSP process_sp(GetProcessSP());
2929 stop_id = process_sp->GetStopID();
2931 stop_id = m_section_load_history.GetLastStopID();
2932 return m_section_load_history.SetSectionUnloaded (stop_id, section_sp, load_addr);
2936 Target::ClearAllLoadedSections ()
2938 m_section_load_history.Clear();
2942 Target::Launch (ProcessLaunchInfo &launch_info, Stream *stream)
2945 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
2948 log->Printf ("Target::%s() called for %s", __FUNCTION__, launch_info.GetExecutableFile().GetPath().c_str ());
2950 StateType state = eStateInvalid;
2952 // Scope to temporarily get the process state in case someone has manually
2953 // remotely connected already to a process and we can skip the platform
2956 ProcessSP process_sp (GetProcessSP());
2960 state = process_sp->GetState();
2962 log->Printf ("Target::%s the process exists, and its current state is %s", __FUNCTION__, StateAsCString (state));
2967 log->Printf ("Target::%s the process instance doesn't currently exist.", __FUNCTION__);
2971 launch_info.GetFlags().Set (eLaunchFlagDebug);
2973 // Get the value of synchronous execution here. If you wait till after you have started to
2974 // run, then you could have hit a breakpoint, whose command might switch the value, and
2975 // then you'll pick up that incorrect value.
2976 Debugger &debugger = GetDebugger();
2977 const bool synchronous_execution = debugger.GetCommandInterpreter().GetSynchronous ();
2979 PlatformSP platform_sp (GetPlatform());
2981 // Finalize the file actions, and if none were given, default to opening
2982 // up a pseudo terminal
2983 const bool default_to_use_pty = platform_sp ? platform_sp->IsHost() : false;
2985 log->Printf ("Target::%s have platform=%s, platform_sp->IsHost()=%s, default_to_use_pty=%s",
2987 platform_sp ? "true" : "false",
2988 platform_sp ? (platform_sp->IsHost () ? "true" : "false") : "n/a",
2989 default_to_use_pty ? "true" : "false");
2991 launch_info.FinalizeFileActions (this, default_to_use_pty);
2993 if (state == eStateConnected)
2995 if (launch_info.GetFlags().Test (eLaunchFlagLaunchInTTY))
2997 error.SetErrorString("can't launch in tty when launching through a remote connection");
3002 if (!launch_info.GetArchitecture().IsValid())
3003 launch_info.GetArchitecture() = GetArchitecture();
3005 // If we're not already connected to the process, and if we have a platform that can launch a process for debugging, go ahead and do that here.
3006 if (state != eStateConnected && platform_sp && platform_sp->CanDebugProcess ())
3009 log->Printf ("Target::%s asking the platform to debug the process", __FUNCTION__);
3011 // Get a weak pointer to the previous process if we have one
3012 ProcessWP process_wp;
3014 process_wp = m_process_sp;
3015 m_process_sp = GetPlatform()->DebugProcess (launch_info,
3020 // Cleanup the old process since someone might still have a strong
3021 // reference to this process and we would like to allow it to cleanup
3022 // as much as it can without the object being destroyed. We try to
3023 // lock the shared pointer and if that works, then someone else still
3024 // has a strong reference to the process.
3026 ProcessSP old_process_sp(process_wp.lock());
3028 old_process_sp->Finalize();
3033 log->Printf ("Target::%s the platform doesn't know how to debug a process, getting a process plugin to do this for us.", __FUNCTION__);
3035 if (state == eStateConnected)
3037 assert(m_process_sp);
3041 // Use a Process plugin to construct the process.
3042 const char *plugin_name = launch_info.GetProcessPluginName();
3043 CreateProcess(launch_info.GetListenerForProcess(debugger), plugin_name, nullptr);
3046 // Since we didn't have a platform launch the process, launch it here.
3048 error = m_process_sp->Launch (launch_info);
3053 if (error.Success())
3054 error.SetErrorString("failed to launch or debug process");
3058 if (error.Success())
3060 if (synchronous_execution || !launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
3062 ListenerSP hijack_listener_sp (launch_info.GetHijackListener());
3063 if (!hijack_listener_sp)
3065 hijack_listener_sp.reset(new Listener("lldb.Target.Launch.hijack"));
3066 launch_info.SetHijackListener(hijack_listener_sp);
3067 m_process_sp->HijackProcessEvents(hijack_listener_sp.get());
3070 StateType state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, false, hijack_listener_sp.get(), nullptr);
3072 if (state == eStateStopped)
3074 if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry))
3076 if (synchronous_execution)
3078 error = m_process_sp->PrivateResume();
3079 if (error.Success())
3081 state = m_process_sp->WaitForProcessToStop(nullptr, nullptr, true, hijack_listener_sp.get(), stream);
3082 const bool must_be_alive = false; // eStateExited is ok, so this must be false
3083 if (!StateIsStoppedState(state, must_be_alive))
3085 error.SetErrorStringWithFormat("process isn't stopped: %s", StateAsCString(state));
3091 m_process_sp->RestoreProcessEvents();
3092 error = m_process_sp->PrivateResume();
3094 if (!error.Success())
3097 error2.SetErrorStringWithFormat("process resume at entry point failed: %s", error.AsCString());
3102 else if (state == eStateExited)
3104 bool with_shell = !!launch_info.GetShell();
3105 const int exit_status = m_process_sp->GetExitStatus();
3106 const char *exit_desc = m_process_sp->GetExitDescription();
3107 #define LAUNCH_SHELL_MESSAGE "\n'r' and 'run' are aliases that default to launching through a shell.\nTry launching without going through a shell by using 'process launch'."
3108 if (exit_desc && exit_desc[0])
3111 error.SetErrorStringWithFormat ("process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE, exit_status, exit_desc);
3113 error.SetErrorStringWithFormat ("process exited with status %i (%s)", exit_status, exit_desc);
3118 error.SetErrorStringWithFormat ("process exited with status %i" LAUNCH_SHELL_MESSAGE, exit_status);
3120 error.SetErrorStringWithFormat ("process exited with status %i", exit_status);
3125 error.SetErrorStringWithFormat ("initial process state wasn't stopped: %s", StateAsCString(state));
3128 m_process_sp->RestoreProcessEvents ();
3133 error2.SetErrorStringWithFormat ("process launch failed: %s", error.AsCString());
3140 Target::Attach (ProcessAttachInfo &attach_info, Stream *stream)
3142 auto state = eStateInvalid;
3143 auto process_sp = GetProcessSP ();
3146 state = process_sp->GetState ();
3147 if (process_sp->IsAlive () && state != eStateConnected)
3149 if (state == eStateAttaching)
3150 return Error ("process attach is in progress");
3151 return Error ("a process is already being debugged");
3155 const ModuleSP old_exec_module_sp = GetExecutableModule ();
3157 // If no process info was specified, then use the target executable
3158 // name as the process to attach to by default
3159 if (!attach_info.ProcessInfoSpecified ())
3161 if (old_exec_module_sp)
3162 attach_info.GetExecutableFile ().GetFilename () = old_exec_module_sp->GetPlatformFileSpec ().GetFilename ();
3164 if (!attach_info.ProcessInfoSpecified ())
3166 return Error ("no process specified, create a target with a file, or specify the --pid or --name");
3170 const auto platform_sp = GetDebugger ().GetPlatformList ().GetSelectedPlatform ();
3171 ListenerSP hijack_listener_sp;
3172 const bool async = attach_info.GetAsync();
3175 hijack_listener_sp.reset (new Listener ("lldb.Target.Attach.attach.hijack"));
3176 attach_info.SetHijackListener (hijack_listener_sp);
3180 if (state != eStateConnected && platform_sp != nullptr && platform_sp->CanDebugProcess ())
3182 SetPlatform (platform_sp);
3183 process_sp = platform_sp->Attach (attach_info, GetDebugger (), this, error);
3187 if (state != eStateConnected)
3189 const char *plugin_name = attach_info.GetProcessPluginName ();
3190 process_sp = CreateProcess (attach_info.GetListenerForProcess (GetDebugger ()), plugin_name, nullptr);
3191 if (process_sp == nullptr)
3193 error.SetErrorStringWithFormat ("failed to create process using plugin %s", (plugin_name) ? plugin_name : "null");
3197 if (hijack_listener_sp)
3198 process_sp->HijackProcessEvents (hijack_listener_sp.get ());
3199 error = process_sp->Attach (attach_info);
3202 if (error.Success () && process_sp)
3206 process_sp->RestoreProcessEvents ();
3210 state = process_sp->WaitForProcessToStop (nullptr, nullptr, false, attach_info.GetHijackListener ().get (), stream);
3211 process_sp->RestoreProcessEvents ();
3213 if (state != eStateStopped)
3215 const char *exit_desc = process_sp->GetExitDescription ();
3217 error.SetErrorStringWithFormat ("%s", exit_desc);
3219 error.SetErrorString ("process did not stop (no such process or permission problem?)");
3220 process_sp->Destroy (false);
3227 //--------------------------------------------------------------
3229 //--------------------------------------------------------------
3230 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) :
3232 m_target_sp (target_sp),
3240 Target::StopHook::StopHook (const StopHook &rhs) :
3241 UserID (rhs.GetID()),
3242 m_target_sp (rhs.m_target_sp),
3243 m_commands (rhs.m_commands),
3244 m_specifier_sp (rhs.m_specifier_sp),
3245 m_thread_spec_ap (),
3246 m_active (rhs.m_active)
3248 if (rhs.m_thread_spec_ap)
3249 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get()));
3252 Target::StopHook::~StopHook() = default;
3255 Target::StopHook::SetSpecifier(SymbolContextSpecifier *specifier)
3257 m_specifier_sp.reset(specifier);
3261 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier)
3263 m_thread_spec_ap.reset (specifier);
3267 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const
3269 int indent_level = s->GetIndentLevel();
3271 s->SetIndentLevel(indent_level + 2);
3273 s->Printf ("Hook: %" PRIu64 "\n", GetID());
3275 s->Indent ("State: enabled\n");
3277 s->Indent ("State: disabled\n");
3282 s->PutCString ("Specifier:\n");
3283 s->SetIndentLevel (indent_level + 4);
3284 m_specifier_sp->GetDescription (s, level);
3285 s->SetIndentLevel (indent_level + 2);
3288 if (m_thread_spec_ap)
3291 s->Indent("Thread:\n");
3292 m_thread_spec_ap->GetDescription (&tmp, level);
3293 s->SetIndentLevel (indent_level + 4);
3294 s->Indent (tmp.GetData());
3295 s->PutCString ("\n");
3296 s->SetIndentLevel (indent_level + 2);
3299 s->Indent ("Commands: \n");
3300 s->SetIndentLevel (indent_level + 4);
3301 uint32_t num_commands = m_commands.GetSize();
3302 for (uint32_t i = 0; i < num_commands; i++)
3304 s->Indent(m_commands.GetStringAtIndex(i));
3305 s->PutCString ("\n");
3307 s->SetIndentLevel (indent_level);
3310 //--------------------------------------------------------------
3311 // class TargetProperties
3312 //--------------------------------------------------------------
3314 OptionEnumValueElement
3315 lldb_private::g_dynamic_value_types[] =
3317 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"},
3318 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."},
3319 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."},
3320 { 0, nullptr, nullptr }
3323 static OptionEnumValueElement
3324 g_inline_breakpoint_enums[] =
3326 { eInlineBreakpointsNever, "never", "Never look for inline breakpoint locations (fastest). This setting should only be used if you know that no inlining occurs in your programs."},
3327 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."},
3328 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."},
3329 { 0, nullptr, nullptr }
3332 typedef enum x86DisassemblyFlavor
3334 eX86DisFlavorDefault,
3337 } x86DisassemblyFlavor;
3339 static OptionEnumValueElement
3340 g_x86_dis_flavor_value_types[] =
3342 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
3343 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."},
3344 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."},
3345 { 0, nullptr, nullptr }
3348 static OptionEnumValueElement
3349 g_hex_immediate_style_values[] =
3351 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."},
3352 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."},
3353 { 0, nullptr, nullptr }
3356 static OptionEnumValueElement
3357 g_load_script_from_sym_file_values[] =
3359 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"},
3360 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."},
3361 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."},
3362 { 0, nullptr, nullptr }
3365 static OptionEnumValueElement
3366 g_memory_module_load_level_values[] =
3368 { eMemoryModuleLoadLevelMinimal, "minimal" , "Load minimal information when loading modules from memory. Currently this setting loads sections only."},
3369 { eMemoryModuleLoadLevelPartial, "partial" , "Load partial information when loading modules from memory. Currently this setting loads sections and function bounds."},
3370 { eMemoryModuleLoadLevelComplete, "complete", "Load complete information when loading modules from memory. Currently this setting loads sections and all symbols."},
3371 { 0, nullptr, nullptr }
3374 static PropertyDefinition
3377 { "default-arch" , OptionValue::eTypeArch , true , 0 , nullptr, nullptr, "Default architecture to choose, when there's a choice." },
3378 { "move-to-nearest-code" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Move breakpoints to nearest code." },
3379 { "language" , OptionValue::eTypeLanguage , false, eLanguageTypeUnknown , nullptr, nullptr, "The language to use when interpreting expressions entered in commands." },
3380 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "Path to a file containing expressions to be prepended to all expressions." },
3381 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eDynamicDontRunTarget , nullptr, g_dynamic_value_types, "Should printed values be shown as their dynamic value." },
3382 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Should synthetic values be used by default whenever available." },
3383 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Skip function prologues when setting breakpoints by name." },
3384 { "source-map" , OptionValue::eTypePathMap , false, 0 , nullptr, nullptr, "Source path remappings are used to track the change of location between a source file when built, and "
3385 "where it exists on the current system. It consists of an array of duples, the first element of each duple is "
3386 "some part (starting at the root) of the path to the file when it was built, "
3387 "and the second is where the remainder of the original build hierarchy is rooted on the local system. "
3388 "Each element of the array is checked in order and the first one that results in a match wins." },
3389 { "exec-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "Executable search paths to use when locating executable files whose paths don't match the local file system." },
3390 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating debug symbol files." },
3391 { "clang-module-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , nullptr, nullptr, "List of directories to be searched when locating modules for Clang." },
3392 { "auto-import-clang-modules" , OptionValue::eTypeBoolean , false, false , nullptr, nullptr, "Automatically load Clang modules referred to by the program." },
3393 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , nullptr, nullptr, "Maximum number of children to expand in any level of depth." },
3394 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of characters to show when using %s in summary strings." },
3395 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , nullptr, nullptr, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." },
3396 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Consult the platform module avoid list when setting non-module specific breakpoints." },
3397 { "arg0" , OptionValue::eTypeString , false, 0 , nullptr, nullptr, "The first argument passed to the program in the argument array which can be different from the executable itself." },
3398 { "run-args" , OptionValue::eTypeArgs , false, 0 , nullptr, nullptr, "A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0." },
3399 { "env-vars" , OptionValue::eTypeDictionary, false, OptionValue::eTypeString , nullptr, nullptr, "A list of all the environment variables to be passed to the executable's environment, and their values." },
3400 { "inherit-env" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Inherit the environment from the process that is running LLDB." },
3401 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for reading its standard input." },
3402 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard output." },
3403 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , nullptr, nullptr, "The file/path to be used by the executable program for writing its standard error." },
3404 { "detach-on-error" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "debugserver will detach (rather than killing) a process if it loses connection with lldb." },
3405 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , nullptr, nullptr, "Disable Address Space Layout Randomization (ASLR)" },
3406 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , nullptr, nullptr, "Disable stdin/stdout for process (e.g. for a GUI application)" },
3407 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsAlways , nullptr, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. "
3408 "Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. "
3409 "Usually this is limited to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. "
3410 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. "
3411 "Always checking for inlined breakpoint locations can be expensive (memory and time), so if you have a project with many headers "
3412 "and find that setting breakpoints is slow, then you can change this setting to headers. "
3413 "This setting allows you to control exactly which strategy is used when setting "
3414 "file and line breakpoints." },
3415 // FIXME: This is the wrong way to do per-architecture settings, but we don't have a general per architecture settings system in place yet.
3416 { "x86-disassembly-flavor" , OptionValue::eTypeEnum , false, eX86DisFlavorDefault, nullptr, g_x86_dis_flavor_value_types, "The default disassembly flavor to use for x86 or x86-64 targets." },
3417 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, nullptr, nullptr, "Show immediates in disassembly as hexadecimal." },
3418 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, nullptr, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." },
3419 { "use-fast-stepping" , OptionValue::eTypeBoolean , false, true, nullptr, nullptr, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." },
3420 { "load-script-from-symbol-file" , OptionValue::eTypeEnum , false, eLoadScriptFromSymFileWarn, nullptr, g_load_script_from_sym_file_values, "Allow LLDB to load scripting resources embedded in symbol files when available." },
3421 { "memory-module-load-level" , OptionValue::eTypeEnum , false, eMemoryModuleLoadLevelComplete, nullptr, g_memory_module_load_level_values,
3422 "Loading modules from memory can be slow as reading the symbol tables and other data can take a long time depending on your connection to the debug target. "
3423 "This setting helps users control how much information gets loaded when loading modules from memory."
3424 "'complete' is the default value for this setting which will load all sections and symbols by reading them from memory (slowest, most accurate). "
3425 "'partial' will load sections and attempt to find function bounds without downloading the symbol table (faster, still accurate, missing symbol names). "
3426 "'minimal' is the fastest setting and will load section data with no symbols, but should rarely be used as stack frames in these memory regions will be inaccurate and not provide any context (fastest). " },
3427 { "display-expression-in-crashlogs" , OptionValue::eTypeBoolean , false, false, nullptr, nullptr, "Expressions that crash will show up in crash logs if the host system supports executable specific crash log strings and this setting is set to true." },
3428 { "trap-handler-names" , OptionValue::eTypeArray , true, OptionValue::eTypeString, nullptr, nullptr, "A list of trap handler function names, e.g. a common Unix user process one is _sigtramp." },
3429 { "display-runtime-support-values" , OptionValue::eTypeBoolean , false, false, nullptr, nullptr, "If true, LLDB will show variables that are meant to support the operation of a language's runtime support." },
3430 { "non-stop-mode" , OptionValue::eTypeBoolean , false, 0, nullptr, nullptr, "Disable lock-step debugging, instead control threads independently." },
3431 { nullptr , OptionValue::eTypeInvalid , false, 0 , nullptr, nullptr, nullptr }
3436 ePropertyDefaultArch,
3437 ePropertyMoveToNearestCode,
3439 ePropertyExprPrefix,
3440 ePropertyPreferDynamic,
3441 ePropertyEnableSynthetic,
3442 ePropertySkipPrologue,
3444 ePropertyExecutableSearchPaths,
3445 ePropertyDebugFileSearchPaths,
3446 ePropertyClangModuleSearchPaths,
3447 ePropertyAutoImportClangModules,
3448 ePropertyMaxChildrenCount,
3449 ePropertyMaxSummaryLength,
3450 ePropertyMaxMemReadSize,
3451 ePropertyBreakpointUseAvoidList,
3455 ePropertyInheritEnv,
3457 ePropertyOutputPath,
3459 ePropertyDetachOnError,
3460 ePropertyDisableASLR,
3461 ePropertyDisableSTDIO,
3462 ePropertyInlineStrategy,
3463 ePropertyDisassemblyFlavor,
3464 ePropertyUseHexImmediates,
3465 ePropertyHexImmediateStyle,
3466 ePropertyUseFastStepping,
3467 ePropertyLoadScriptFromSymbolFile,
3468 ePropertyMemoryModuleLoadLevel,
3469 ePropertyDisplayExpressionsInCrashlogs,
3470 ePropertyTrapHandlerNames,
3471 ePropertyDisplayRuntimeSupportValues,
3472 ePropertyNonStopModeEnabled
3475 class TargetOptionValueProperties : public OptionValueProperties
3478 TargetOptionValueProperties (const ConstString &name) :
3479 OptionValueProperties (name),
3481 m_got_host_env (false)
3485 // This constructor is used when creating TargetOptionValueProperties when it
3486 // is part of a new lldb_private::Target instance. It will copy all current
3487 // global property values as needed
3488 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) :
3489 OptionValueProperties(*target_properties_sp->GetValueProperties()),
3491 m_got_host_env (false)
3496 GetPropertyAtIndex(const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const override
3498 // When getting the value for a key from the target options, we will always
3499 // try and grab the setting from the current target if there is one. Else we just
3500 // use the one from this instance.
3501 if (idx == ePropertyEnvVars)
3502 GetHostEnvironmentIfNeeded ();
3506 Target *target = exe_ctx->GetTargetPtr();
3509 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get());
3510 if (this != target_properties)
3511 return target_properties->ProtectedGetPropertyAtIndex (idx);
3514 return ProtectedGetPropertyAtIndex (idx);
3520 return m_target->shared_from_this();
3525 GetHostEnvironmentIfNeeded () const
3527 if (!m_got_host_env)
3531 m_got_host_env = true;
3532 const uint32_t idx = ePropertyInheritEnv;
3533 if (GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0))
3535 PlatformSP platform_sp (m_target->GetPlatform());
3539 if (platform_sp->GetEnvironment(env))
3541 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary(nullptr, ePropertyEnvVars);
3544 const bool can_replace = false;
3545 const size_t envc = env.GetSize();
3546 for (size_t idx=0; idx<envc; idx++)
3548 const char *env_entry = env.GetStringAtIndex (idx);
3551 const char *equal_pos = ::strchr(env_entry, '=');
3553 // It is ok to have environment variables with no values
3554 const char *value = nullptr;
3557 key.SetCStringWithLength(env_entry, equal_pos - env_entry);
3559 value = equal_pos + 1;
3563 key.SetCString(env_entry);
3565 // Don't allow existing keys to be replaced with ones we get from the platform environment
3566 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace);
3577 mutable bool m_got_host_env;
3580 //----------------------------------------------------------------------
3582 //----------------------------------------------------------------------
3583 TargetProperties::TargetProperties (Target *target) :
3589 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
3591 // Set callbacks to update launch_info whenever "settins set" updated any of these properties
3592 m_collection_sp->SetValueChangedCallback(ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
3593 m_collection_sp->SetValueChangedCallback(ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
3594 m_collection_sp->SetValueChangedCallback(ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this);
3595 m_collection_sp->SetValueChangedCallback(ePropertyInputPath, TargetProperties::InputPathValueChangedCallback, this);
3596 m_collection_sp->SetValueChangedCallback(ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback, this);
3597 m_collection_sp->SetValueChangedCallback(ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback, this);
3598 m_collection_sp->SetValueChangedCallback(ePropertyDetachOnError, TargetProperties::DetachOnErrorValueChangedCallback, this);
3599 m_collection_sp->SetValueChangedCallback(ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback, this);
3600 m_collection_sp->SetValueChangedCallback(ePropertyDisableSTDIO, TargetProperties::DisableSTDIOValueChangedCallback, this);
3602 // Update m_launch_info once it was created
3603 Arg0ValueChangedCallback(this, nullptr);
3604 RunArgsValueChangedCallback(this, nullptr);
3605 //EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in Target::GetPlatform()
3606 InputPathValueChangedCallback(this, nullptr);
3607 OutputPathValueChangedCallback(this, nullptr);
3608 ErrorPathValueChangedCallback(this, nullptr);
3609 DetachOnErrorValueChangedCallback(this, nullptr);
3610 DisableASLRValueChangedCallback(this, nullptr);
3611 DisableSTDIOValueChangedCallback(this, nullptr);
3615 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target")));
3616 m_collection_sp->Initialize(g_properties);
3617 m_collection_sp->AppendProperty(ConstString("process"),
3618 ConstString("Settings specify to processes."),
3620 Process::GetGlobalProperties()->GetValueProperties());
3624 TargetProperties::~TargetProperties() = default;
3627 TargetProperties::GetDefaultArchitecture () const
3629 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch);
3631 return value->GetCurrentValue();
3636 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch)
3638 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(nullptr, ePropertyDefaultArch);
3640 return value->SetCurrentValue(arch, true);
3644 TargetProperties::GetMoveToNearestCode() const
3646 const uint32_t idx = ePropertyMoveToNearestCode;
3647 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3650 lldb::DynamicValueType
3651 TargetProperties::GetPreferDynamicValue() const
3653 const uint32_t idx = ePropertyPreferDynamic;
3654 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3658 TargetProperties::SetPreferDynamicValue (lldb::DynamicValueType d)
3660 const uint32_t idx = ePropertyPreferDynamic;
3661 return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d);
3665 TargetProperties::GetDisableASLR () const
3667 const uint32_t idx = ePropertyDisableASLR;
3668 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3672 TargetProperties::SetDisableASLR (bool b)
3674 const uint32_t idx = ePropertyDisableASLR;
3675 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3679 TargetProperties::GetDetachOnError () const
3681 const uint32_t idx = ePropertyDetachOnError;
3682 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3686 TargetProperties::SetDetachOnError (bool b)
3688 const uint32_t idx = ePropertyDetachOnError;
3689 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3693 TargetProperties::GetDisableSTDIO () const
3695 const uint32_t idx = ePropertyDisableSTDIO;
3696 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3700 TargetProperties::SetDisableSTDIO (bool b)
3702 const uint32_t idx = ePropertyDisableSTDIO;
3703 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3707 TargetProperties::GetDisassemblyFlavor () const
3709 const uint32_t idx = ePropertyDisassemblyFlavor;
3710 const char *return_value;
3712 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3713 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value;
3714 return return_value;
3718 TargetProperties::GetInlineStrategy () const
3720 const uint32_t idx = ePropertyInlineStrategy;
3721 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3725 TargetProperties::GetArg0 () const
3727 const uint32_t idx = ePropertyArg0;
3728 return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, nullptr);
3732 TargetProperties::SetArg0 (const char *arg)
3734 const uint32_t idx = ePropertyArg0;
3735 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, arg);
3736 m_launch_info.SetArg0(arg);
3740 TargetProperties::GetRunArguments (Args &args) const
3742 const uint32_t idx = ePropertyRunArgs;
3743 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
3747 TargetProperties::SetRunArguments (const Args &args)
3749 const uint32_t idx = ePropertyRunArgs;
3750 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
3751 m_launch_info.GetArguments() = args;
3755 TargetProperties::GetEnvironmentAsArgs (Args &env) const
3757 const uint32_t idx = ePropertyEnvVars;
3758 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
3762 TargetProperties::SetEnvironmentFromArgs (const Args &env)
3764 const uint32_t idx = ePropertyEnvVars;
3765 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, env);
3766 m_launch_info.GetEnvironmentEntries() = env;
3770 TargetProperties::GetSkipPrologue() const
3772 const uint32_t idx = ePropertySkipPrologue;
3773 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3777 TargetProperties::GetSourcePathMap () const
3779 const uint32_t idx = ePropertySourceMap;
3780 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr, false, idx);
3781 assert(option_value);
3782 return option_value->GetCurrentValue();
3786 TargetProperties::GetExecutableSearchPaths ()
3788 const uint32_t idx = ePropertyExecutableSearchPaths;
3789 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3790 assert(option_value);
3791 return option_value->GetCurrentValue();
3795 TargetProperties::GetDebugFileSearchPaths ()
3797 const uint32_t idx = ePropertyDebugFileSearchPaths;
3798 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3799 assert(option_value);
3800 return option_value->GetCurrentValue();
3804 TargetProperties::GetClangModuleSearchPaths ()
3806 const uint32_t idx = ePropertyClangModuleSearchPaths;
3807 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr, false, idx);
3808 assert(option_value);
3809 return option_value->GetCurrentValue();
3813 TargetProperties::GetEnableAutoImportClangModules() const
3815 const uint32_t idx = ePropertyAutoImportClangModules;
3816 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3820 TargetProperties::GetEnableSyntheticValue () const
3822 const uint32_t idx = ePropertyEnableSynthetic;
3823 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3827 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const
3829 const uint32_t idx = ePropertyMaxChildrenCount;
3830 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3834 TargetProperties::GetMaximumSizeOfStringSummary() const
3836 const uint32_t idx = ePropertyMaxSummaryLength;
3837 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3841 TargetProperties::GetMaximumMemReadSize () const
3843 const uint32_t idx = ePropertyMaxMemReadSize;
3844 return m_collection_sp->GetPropertyAtIndexAsSInt64(nullptr, idx, g_properties[idx].default_uint_value);
3848 TargetProperties::GetStandardInputPath () const
3850 const uint32_t idx = ePropertyInputPath;
3851 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3855 TargetProperties::SetStandardInputPath (const char *p)
3857 const uint32_t idx = ePropertyInputPath;
3858 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3862 TargetProperties::GetStandardOutputPath () const
3864 const uint32_t idx = ePropertyOutputPath;
3865 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3869 TargetProperties::SetStandardOutputPath (const char *p)
3871 const uint32_t idx = ePropertyOutputPath;
3872 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3876 TargetProperties::GetStandardErrorPath () const
3878 const uint32_t idx = ePropertyErrorPath;
3879 return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3883 TargetProperties::GetLanguage () const
3885 OptionValueLanguage *value = m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(nullptr, ePropertyLanguage);
3887 return value->GetCurrentValue();
3888 return LanguageType();
3892 TargetProperties::GetExpressionPrefixContentsAsCString ()
3894 const uint32_t idx = ePropertyExprPrefix;
3895 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false, idx);
3898 const bool null_terminate = true;
3899 DataBufferSP data_sp(file->GetFileContents(null_terminate));
3901 return (const char *) data_sp->GetBytes();
3907 TargetProperties::SetStandardErrorPath (const char *p)
3909 const uint32_t idx = ePropertyErrorPath;
3910 m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, p);
3914 TargetProperties::GetBreakpointsConsultPlatformAvoidList ()
3916 const uint32_t idx = ePropertyBreakpointUseAvoidList;
3917 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3921 TargetProperties::GetUseHexImmediates () const
3923 const uint32_t idx = ePropertyUseHexImmediates;
3924 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3928 TargetProperties::GetUseFastStepping () const
3930 const uint32_t idx = ePropertyUseFastStepping;
3931 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3935 TargetProperties::GetDisplayExpressionsInCrashlogs () const
3937 const uint32_t idx = ePropertyDisplayExpressionsInCrashlogs;
3938 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, g_properties[idx].default_uint_value != 0);
3941 LoadScriptFromSymFile
3942 TargetProperties::GetLoadScriptFromSymbolFile () const
3944 const uint32_t idx = ePropertyLoadScriptFromSymbolFile;
3945 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3948 Disassembler::HexImmediateStyle
3949 TargetProperties::GetHexImmediateStyle () const
3951 const uint32_t idx = ePropertyHexImmediateStyle;
3952 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3955 MemoryModuleLoadLevel
3956 TargetProperties::GetMemoryModuleLoadLevel() const
3958 const uint32_t idx = ePropertyMemoryModuleLoadLevel;
3959 return (MemoryModuleLoadLevel)m_collection_sp->GetPropertyAtIndexAsEnumeration(nullptr, idx, g_properties[idx].default_uint_value);
3963 TargetProperties::GetUserSpecifiedTrapHandlerNames (Args &args) const
3965 const uint32_t idx = ePropertyTrapHandlerNames;
3966 return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
3970 TargetProperties::SetUserSpecifiedTrapHandlerNames (const Args &args)
3972 const uint32_t idx = ePropertyTrapHandlerNames;
3973 m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
3977 TargetProperties::GetDisplayRuntimeSupportValues () const
3979 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
3980 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
3984 TargetProperties::SetDisplayRuntimeSupportValues (bool b)
3986 const uint32_t idx = ePropertyDisplayRuntimeSupportValues;
3987 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3991 TargetProperties::GetNonStopModeEnabled () const
3993 const uint32_t idx = ePropertyNonStopModeEnabled;
3994 return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
3998 TargetProperties::SetNonStopModeEnabled (bool b)
4000 const uint32_t idx = ePropertyNonStopModeEnabled;
4001 m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4004 const ProcessLaunchInfo &
4005 TargetProperties::GetProcessLaunchInfo ()
4007 m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work
4008 return m_launch_info;
4012 TargetProperties::SetProcessLaunchInfo(const ProcessLaunchInfo &launch_info)
4014 m_launch_info = launch_info;
4015 SetArg0(launch_info.GetArg0());
4016 SetRunArguments(launch_info.GetArguments());
4017 SetEnvironmentFromArgs(launch_info.GetEnvironmentEntries());
4018 const FileAction *input_file_action = launch_info.GetFileActionForFD(STDIN_FILENO);
4019 if (input_file_action)
4021 const char *input_path = input_file_action->GetPath();
4023 SetStandardInputPath(input_path);
4025 const FileAction *output_file_action = launch_info.GetFileActionForFD(STDOUT_FILENO);
4026 if (output_file_action)
4028 const char *output_path = output_file_action->GetPath();
4030 SetStandardOutputPath(output_path);
4032 const FileAction *error_file_action = launch_info.GetFileActionForFD(STDERR_FILENO);
4033 if (error_file_action)
4035 const char *error_path = error_file_action->GetPath();
4037 SetStandardErrorPath(error_path);
4039 SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError));
4040 SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR));
4041 SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO));
4045 TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr, OptionValue *)
4047 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4048 this_->m_launch_info.SetArg0(this_->GetArg0());
4052 TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr, OptionValue *)
4054 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4056 if (this_->GetRunArguments(args))
4057 this_->m_launch_info.GetArguments() = args;
4061 TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr, OptionValue *)
4063 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4065 if (this_->GetEnvironmentAsArgs(args))
4066 this_->m_launch_info.GetEnvironmentEntries() = args;
4070 TargetProperties::InputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4072 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4073 this_->m_launch_info.AppendOpenFileAction(STDIN_FILENO, this_->GetStandardInputPath(), true, false);
4077 TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4079 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4080 this_->m_launch_info.AppendOpenFileAction(STDOUT_FILENO, this_->GetStandardOutputPath(), false, true);
4084 TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr, OptionValue *)
4086 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4087 this_->m_launch_info.AppendOpenFileAction(STDERR_FILENO, this_->GetStandardErrorPath(), false, true);
4091 TargetProperties::DetachOnErrorValueChangedCallback(void *target_property_ptr, OptionValue *)
4093 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4094 if (this_->GetDetachOnError())
4095 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);
4097 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError);
4101 TargetProperties::DisableASLRValueChangedCallback(void *target_property_ptr, OptionValue *)
4103 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4104 if (this_->GetDisableASLR())
4105 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR);
4107 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR);
4111 TargetProperties::DisableSTDIOValueChangedCallback(void *target_property_ptr, OptionValue *)
4113 TargetProperties *this_ = reinterpret_cast<TargetProperties *>(target_property_ptr);
4114 if (this_->GetDisableSTDIO())
4115 this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
4117 this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
4120 //----------------------------------------------------------------------
4121 // Target::TargetEventData
4122 //----------------------------------------------------------------------
4124 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp) :
4126 m_target_sp (target_sp),
4131 Target::TargetEventData::TargetEventData (const lldb::TargetSP &target_sp, const ModuleList &module_list) :
4133 m_target_sp (target_sp),
4134 m_module_list (module_list)
4138 Target::TargetEventData::~TargetEventData() = default;
4141 Target::TargetEventData::GetFlavorString ()
4143 static ConstString g_flavor ("Target::TargetEventData");
4148 Target::TargetEventData::Dump (Stream *s) const
4152 const Target::TargetEventData *
4153 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr)
4157 const EventData *event_data = event_ptr->GetData();
4158 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString())
4159 return static_cast <const TargetEventData *> (event_ptr->GetData());
4165 Target::TargetEventData::GetTargetFromEvent (const Event *event_ptr)
4168 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
4170 target_sp = event_data->m_target_sp;
4175 Target::TargetEventData::GetModuleListFromEvent (const Event *event_ptr)
4177 ModuleList module_list;
4178 const TargetEventData *event_data = GetEventDataFromEvent (event_ptr);
4180 module_list = event_data->m_module_list;