LLDB  mainline
Target.cpp
Go to the documentation of this file.
1 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "lldb/Target/Target.h"
21 #include "lldb/Core/Debugger.h"
22 #include "lldb/Core/Module.h"
23 #include "lldb/Core/ModuleSpec.h"
25 #include "lldb/Core/SearchFilter.h"
26 #include "lldb/Core/Section.h"
28 #include "lldb/Core/StreamFile.h"
30 #include "lldb/Core/ValueObject.h"
31 #include "lldb/Expression/REPL.h"
33 #include "lldb/Host/Host.h"
34 #include "lldb/Host/PosixApi.h"
41 #include "lldb/Symbol/Function.h"
42 #include "lldb/Symbol/ObjectFile.h"
43 #include "lldb/Symbol/Symbol.h"
44 #include "lldb/Target/Language.h"
47 #include "lldb/Target/Process.h"
49 #include "lldb/Target/StackFrame.h"
51 #include "lldb/Target/Thread.h"
52 #include "lldb/Target/ThreadSpec.h"
53 #include "lldb/Utility/Event.h"
54 #include "lldb/Utility/FileSpec.h"
56 #include "lldb/Utility/Log.h"
57 #include "lldb/Utility/State.h"
59 #include "lldb/Utility/Timer.h"
60 
61 #include <memory>
62 #include <mutex>
63 
64 using namespace lldb;
65 using namespace lldb_private;
66 
67 constexpr std::chrono::milliseconds EvaluateExpressionOptions::default_timeout;
68 
69 Target::Arch::Arch(const ArchSpec &spec)
70  : m_spec(spec),
71  m_plugin_up(PluginManager::CreateArchitectureInstance(spec)) {}
72 
74  m_spec = spec;
76  return *this;
77 }
78 
80  static ConstString class_name("lldb.target");
81  return class_name;
82 }
83 
84 Target::Target(Debugger &debugger, const ArchSpec &target_arch,
85  const lldb::PlatformSP &platform_sp, bool is_dummy_target)
86  : TargetProperties(this),
89  ExecutionContextScope(), m_debugger(debugger), m_platform_sp(platform_sp),
90  m_mutex(), m_arch(target_arch), m_images(this), m_section_load_history(),
95  m_valid(true), m_suppress_stop_hooks(false),
96  m_is_dummy_target(is_dummy_target),
97  m_stats_storage(static_cast<int>(StatisticKind::StatisticMax))
98 
99 {
100  SetEventName(eBroadcastBitBreakpointChanged, "breakpoint-changed");
101  SetEventName(eBroadcastBitModulesLoaded, "modules-loaded");
102  SetEventName(eBroadcastBitModulesUnloaded, "modules-unloaded");
103  SetEventName(eBroadcastBitWatchpointChanged, "watchpoint-changed");
104  SetEventName(eBroadcastBitSymbolsLoaded, "symbols-loaded");
105 
107 
109  if (log)
110  log->Printf("%p Target::Target()", static_cast<void *>(this));
111  if (target_arch.IsValid()) {
113  "Target::Target created with architecture %s (%s)",
114  target_arch.GetArchitectureName(),
115  target_arch.GetTriple().getTriple().c_str());
116  }
117 }
118 
121  if (log)
122  log->Printf("%p Target::~Target()", static_cast<void *>(this));
124 }
125 
126 void Target::PrimeFromDummyTarget(Target *target) {
127  if (!target)
128  return;
129 
130  m_stop_hooks = target->m_stop_hooks;
131 
132  for (BreakpointSP breakpoint_sp : target->m_breakpoint_list.Breakpoints()) {
133  if (breakpoint_sp->IsInternal())
134  continue;
135 
136  BreakpointSP new_bp(new Breakpoint(*this, *breakpoint_sp.get()));
137  AddBreakpoint(new_bp, false);
138  }
139 
140  for (auto bp_name_entry : target->m_breakpoint_names)
141  {
142 
143  BreakpointName *new_bp_name = new BreakpointName(*bp_name_entry.second);
144  AddBreakpointName(new_bp_name);
145  }
146 }
147 
148 void Target::Dump(Stream *s, lldb::DescriptionLevel description_level) {
149  // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
150  if (description_level != lldb::eDescriptionLevelBrief) {
151  s->Indent();
152  s->PutCString("Target\n");
153  s->IndentMore();
154  m_images.Dump(s);
157  s->IndentLess();
158  } else {
159  Module *exe_module = GetExecutableModulePointer();
160  if (exe_module)
161  s->PutCString(exe_module->GetFileSpec().GetFilename().GetCString());
162  else
163  s->PutCString("No executable module.");
164  }
165 }
166 
168  // Do any cleanup of the target we need to do between process instances.
169  // NB It is better to do this before destroying the process in case the
170  // clean up needs some help from the process.
173  // Disable watchpoints just on the debugger side.
174  std::unique_lock<std::recursive_mutex> lock;
175  this->GetWatchpointList().GetListMutex(lock);
176  DisableAllWatchpoints(false);
179 }
180 
182  if (m_process_sp) {
184  if (m_process_sp->IsAlive())
185  m_process_sp->Destroy(false);
186 
187  m_process_sp->Finalize();
188 
189  CleanupProcess();
190 
191  m_process_sp.reset();
192  }
193 }
194 
195 const lldb::ProcessSP &Target::CreateProcess(ListenerSP listener_sp,
196  llvm::StringRef plugin_name,
197  const FileSpec *crash_file) {
198  if (!listener_sp)
199  listener_sp = GetDebugger().GetListener();
201  m_process_sp = Process::FindPlugin(shared_from_this(), plugin_name,
202  listener_sp, crash_file);
203  return m_process_sp;
204 }
205 
206 const lldb::ProcessSP &Target::GetProcessSP() const { return m_process_sp; }
207 
208 lldb::REPLSP Target::GetREPL(Status &err, lldb::LanguageType language,
209  const char *repl_options, bool can_create) {
210  if (language == eLanguageTypeUnknown) {
211  std::set<LanguageType> repl_languages;
212 
214 
215  if (repl_languages.size() == 1) {
216  language = *repl_languages.begin();
217  } else if (repl_languages.size() == 0) {
219  "LLDB isn't configured with REPL support for any languages.");
220  return REPLSP();
221  } else {
223  "Multiple possible REPL languages. Please specify a language.");
224  return REPLSP();
225  }
226  }
227 
228  REPLMap::iterator pos = m_repl_map.find(language);
229 
230  if (pos != m_repl_map.end()) {
231  return pos->second;
232  }
233 
234  if (!can_create) {
236  "Couldn't find an existing REPL for %s, and can't create a new one",
238  return lldb::REPLSP();
239  }
240 
241  Debugger *const debugger = nullptr;
242  lldb::REPLSP ret = REPL::Create(err, language, debugger, this, repl_options);
243 
244  if (ret) {
245  m_repl_map[language] = ret;
246  return m_repl_map[language];
247  }
248 
249  if (err.Success()) {
250  err.SetErrorStringWithFormat("Couldn't create a REPL for %s",
252  }
253 
254  return lldb::REPLSP();
255 }
256 
257 void Target::SetREPL(lldb::LanguageType language, lldb::REPLSP repl_sp) {
258  lldbassert(!m_repl_map.count(language));
259 
260  m_repl_map[language] = repl_sp;
261 }
262 
264  std::lock_guard<std::recursive_mutex> guard(m_mutex);
265  m_valid = false;
267  m_platform_sp.reset();
268  m_arch = ArchSpec();
269  ClearModules(true);
271  const bool notify = false;
276  m_search_filter_sp.reset();
277  m_image_search_paths.Clear(notify);
278  m_stop_hooks.clear();
280  m_suppress_stop_hooks = false;
281 }
282 
284  if (internal)
286  else
287  return m_breakpoint_list;
288 }
289 
290 const BreakpointList &Target::GetBreakpointList(bool internal) const {
291  if (internal)
293  else
294  return m_breakpoint_list;
295 }
296 
297 BreakpointSP Target::GetBreakpointByID(break_id_t break_id) {
298  BreakpointSP bp_sp;
299 
300  if (LLDB_BREAK_ID_IS_INTERNAL(break_id))
302  else
303  bp_sp = m_breakpoint_list.FindBreakpointByID(break_id);
304 
305  return bp_sp;
306 }
307 
309  const FileSpecList *containingModules,
310  const FileSpecList *source_file_spec_list,
311  const std::unordered_set<std::string> &function_names,
312  RegularExpression &source_regex, bool internal, bool hardware,
313  LazyBool move_to_nearest_code) {
314  SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
315  containingModules, source_file_spec_list));
316  if (move_to_nearest_code == eLazyBoolCalculate)
317  move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
318  BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex(
319  nullptr, source_regex, function_names,
320  !static_cast<bool>(move_to_nearest_code)));
321 
322  return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
323 }
324 
325 BreakpointSP Target::CreateBreakpoint(const FileSpecList *containingModules,
326  const FileSpec &file, uint32_t line_no,
327  uint32_t column, lldb::addr_t offset,
328  LazyBool check_inlines,
329  LazyBool skip_prologue, bool internal,
330  bool hardware,
331  LazyBool move_to_nearest_code) {
332  FileSpec remapped_file;
333  if (!GetSourcePathMap().ReverseRemapPath(file, remapped_file))
334  remapped_file = file;
335 
336  if (check_inlines == eLazyBoolCalculate) {
337  const InlineStrategy inline_strategy = GetInlineStrategy();
338  switch (inline_strategy) {
340  check_inlines = eLazyBoolNo;
341  break;
342 
344  if (remapped_file.IsSourceImplementationFile())
345  check_inlines = eLazyBoolNo;
346  else
347  check_inlines = eLazyBoolYes;
348  break;
349 
351  check_inlines = eLazyBoolYes;
352  break;
353  }
354  }
355  SearchFilterSP filter_sp;
356  if (check_inlines == eLazyBoolNo) {
357  // Not checking for inlines, we are looking only for matching compile units
358  FileSpecList compile_unit_list;
359  compile_unit_list.Append(remapped_file);
360  filter_sp = GetSearchFilterForModuleAndCUList(containingModules,
361  &compile_unit_list);
362  } else {
363  filter_sp = GetSearchFilterForModuleList(containingModules);
364  }
365  if (skip_prologue == eLazyBoolCalculate)
366  skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
367  if (move_to_nearest_code == eLazyBoolCalculate)
368  move_to_nearest_code = GetMoveToNearestCode() ? eLazyBoolYes : eLazyBoolNo;
369 
370  BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine(
371  nullptr, remapped_file, line_no, column, offset, check_inlines,
372  skip_prologue, !static_cast<bool>(move_to_nearest_code)));
373  return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
374 }
375 
376 BreakpointSP Target::CreateBreakpoint(lldb::addr_t addr, bool internal,
377  bool hardware) {
378  Address so_addr;
379 
380  // Check for any reason we want to move this breakpoint to other address.
381  addr = GetBreakableLoadAddress(addr);
382 
383  // Attempt to resolve our load address if possible, though it is ok if it
384  // doesn't resolve to section/offset.
385 
386  // Try and resolve as a load address if possible
387  GetSectionLoadList().ResolveLoadAddress(addr, so_addr);
388  if (!so_addr.IsValid()) {
389  // The address didn't resolve, so just set this as an absolute address
390  so_addr.SetOffset(addr);
391  }
392  BreakpointSP bp_sp(CreateBreakpoint(so_addr, internal, hardware));
393  return bp_sp;
394 }
395 
396 BreakpointSP Target::CreateBreakpoint(const Address &addr, bool internal,
397  bool hardware) {
398  SearchFilterSP filter_sp(
399  new SearchFilterForUnconstrainedSearches(shared_from_this()));
400  BreakpointResolverSP resolver_sp(
401  new BreakpointResolverAddress(nullptr, addr));
402  return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, false);
403 }
404 
405 lldb::BreakpointSP
407  const FileSpec *file_spec,
408  bool request_hardware) {
409  SearchFilterSP filter_sp(
410  new SearchFilterForUnconstrainedSearches(shared_from_this()));
411  BreakpointResolverSP resolver_sp(
412  new BreakpointResolverAddress(nullptr, file_addr, file_spec));
413  return CreateBreakpoint(filter_sp, resolver_sp, internal, request_hardware,
414  false);
415 }
416 
417 BreakpointSP Target::CreateBreakpoint(
418  const FileSpecList *containingModules,
419  const FileSpecList *containingSourceFiles, const char *func_name,
420  FunctionNameType func_name_type_mask, LanguageType language,
421  lldb::addr_t offset, LazyBool skip_prologue, bool internal, bool hardware) {
422  BreakpointSP bp_sp;
423  if (func_name) {
424  SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
425  containingModules, containingSourceFiles));
426 
427  if (skip_prologue == eLazyBoolCalculate)
428  skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
429  if (language == lldb::eLanguageTypeUnknown)
430  language = GetLanguage();
431 
432  BreakpointResolverSP resolver_sp(new BreakpointResolverName(
433  nullptr, func_name, func_name_type_mask, language, Breakpoint::Exact,
434  offset, skip_prologue));
435  bp_sp = CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
436  }
437  return bp_sp;
438 }
439 
440 lldb::BreakpointSP
441 Target::CreateBreakpoint(const FileSpecList *containingModules,
442  const FileSpecList *containingSourceFiles,
443  const std::vector<std::string> &func_names,
444  FunctionNameType func_name_type_mask,
445  LanguageType language, lldb::addr_t offset,
446  LazyBool skip_prologue, bool internal, bool hardware) {
447  BreakpointSP bp_sp;
448  size_t num_names = func_names.size();
449  if (num_names > 0) {
450  SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
451  containingModules, containingSourceFiles));
452 
453  if (skip_prologue == eLazyBoolCalculate)
454  skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
455  if (language == lldb::eLanguageTypeUnknown)
456  language = GetLanguage();
457 
458  BreakpointResolverSP resolver_sp(
459  new BreakpointResolverName(nullptr, func_names, func_name_type_mask,
460  language, offset, skip_prologue));
461  bp_sp = CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
462  }
463  return bp_sp;
464 }
465 
466 BreakpointSP
467 Target::CreateBreakpoint(const FileSpecList *containingModules,
468  const FileSpecList *containingSourceFiles,
469  const char *func_names[], size_t num_names,
470  FunctionNameType func_name_type_mask,
471  LanguageType language, lldb::addr_t offset,
472  LazyBool skip_prologue, bool internal, bool hardware) {
473  BreakpointSP bp_sp;
474  if (num_names > 0) {
475  SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
476  containingModules, containingSourceFiles));
477 
478  if (skip_prologue == eLazyBoolCalculate) {
479  if (offset == 0)
480  skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
481  else
482  skip_prologue = eLazyBoolNo;
483  }
484  if (language == lldb::eLanguageTypeUnknown)
485  language = GetLanguage();
486 
487  BreakpointResolverSP resolver_sp(new BreakpointResolverName(
488  nullptr, func_names, num_names, func_name_type_mask, language, offset,
489  skip_prologue));
490  resolver_sp->SetOffset(offset);
491  bp_sp = CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
492  }
493  return bp_sp;
494 }
495 
496 SearchFilterSP
497 Target::GetSearchFilterForModule(const FileSpec *containingModule) {
498  SearchFilterSP filter_sp;
499  if (containingModule != nullptr) {
500  // TODO: We should look into sharing module based search filters
501  // across many breakpoints like we do for the simple target based one
502  filter_sp = std::make_shared<SearchFilterByModule>(shared_from_this(),
503  *containingModule);
504  } else {
505  if (!m_search_filter_sp)
507  std::make_shared<SearchFilterForUnconstrainedSearches>(
508  shared_from_this());
509  filter_sp = m_search_filter_sp;
510  }
511  return filter_sp;
512 }
513 
514 SearchFilterSP
515 Target::GetSearchFilterForModuleList(const FileSpecList *containingModules) {
516  SearchFilterSP filter_sp;
517  if (containingModules && containingModules->GetSize() != 0) {
518  // TODO: We should look into sharing module based search filters
519  // across many breakpoints like we do for the simple target based one
520  filter_sp = std::make_shared<SearchFilterByModuleList>(shared_from_this(),
521  *containingModules);
522  } else {
523  if (!m_search_filter_sp)
525  std::make_shared<SearchFilterForUnconstrainedSearches>(
526  shared_from_this());
527  filter_sp = m_search_filter_sp;
528  }
529  return filter_sp;
530 }
531 
533  const FileSpecList *containingModules,
534  const FileSpecList *containingSourceFiles) {
535  if (containingSourceFiles == nullptr || containingSourceFiles->GetSize() == 0)
536  return GetSearchFilterForModuleList(containingModules);
537 
538  SearchFilterSP filter_sp;
539  if (containingModules == nullptr) {
540  // We could make a special "CU List only SearchFilter". Better yet was if
541  // these could be composable, but that will take a little reworking.
542 
543  filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
544  shared_from_this(), FileSpecList(), *containingSourceFiles);
545  } else {
546  filter_sp = std::make_shared<SearchFilterByModuleListAndCU>(
547  shared_from_this(), *containingModules, *containingSourceFiles);
548  }
549  return filter_sp;
550 }
551 
553  const FileSpecList *containingModules,
554  const FileSpecList *containingSourceFiles, RegularExpression &func_regex,
555  lldb::LanguageType requested_language, LazyBool skip_prologue,
556  bool internal, bool hardware) {
557  SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList(
558  containingModules, containingSourceFiles));
559  bool skip = (skip_prologue == eLazyBoolCalculate)
560  ? GetSkipPrologue()
561  : static_cast<bool>(skip_prologue);
562  BreakpointResolverSP resolver_sp(new BreakpointResolverName(
563  nullptr, func_regex, requested_language, 0, skip));
564 
565  return CreateBreakpoint(filter_sp, resolver_sp, internal, hardware, true);
566 }
567 
568 lldb::BreakpointSP
570  bool catch_bp, bool throw_bp, bool internal,
571  Args *additional_args, Status *error) {
572  BreakpointSP exc_bkpt_sp = LanguageRuntime::CreateExceptionBreakpoint(
573  *this, language, catch_bp, throw_bp, internal);
574  if (exc_bkpt_sp && additional_args) {
575  Breakpoint::BreakpointPreconditionSP precondition_sp =
576  exc_bkpt_sp->GetPrecondition();
577  if (precondition_sp && additional_args) {
578  if (error)
579  *error = precondition_sp->ConfigurePrecondition(*additional_args);
580  else
581  precondition_sp->ConfigurePrecondition(*additional_args);
582  }
583  }
584  return exc_bkpt_sp;
585 }
586 
587 lldb::BreakpointSP
588 Target::CreateScriptedBreakpoint(const llvm::StringRef class_name,
589  const FileSpecList *containingModules,
590  const FileSpecList *containingSourceFiles,
591  bool internal,
592  bool request_hardware,
593  StructuredData::ObjectSP extra_args_sp,
594  Status *creation_error)
595 {
596  SearchFilterSP filter_sp;
597 
599  bool has_files = containingSourceFiles && containingSourceFiles->GetSize() > 0;
600  bool has_modules = containingModules && containingModules->GetSize() > 0;
601 
602  if (has_files && has_modules) {
604  containingModules, containingSourceFiles);
605  } else if (has_files) {
607  nullptr, containingSourceFiles);
608  } else if (has_modules) {
609  filter_sp = GetSearchFilterForModuleList(containingModules);
610  } else {
611  filter_sp = std::make_shared<SearchFilterForUnconstrainedSearches>(
612  shared_from_this());
613  }
614 
615  StructuredDataImpl *extra_args_impl = new StructuredDataImpl();
616  if (extra_args_sp)
617  extra_args_impl->SetObjectSP(extra_args_sp);
618 
619  BreakpointResolverSP resolver_sp(new BreakpointResolverScripted(
620  nullptr, class_name, depth, extra_args_impl,
621  *GetDebugger().GetScriptInterpreter()));
622  return CreateBreakpoint(filter_sp, resolver_sp, internal, false, true);
623 
624 }
625 
626 
627 BreakpointSP Target::CreateBreakpoint(SearchFilterSP &filter_sp,
628  BreakpointResolverSP &resolver_sp,
629  bool internal, bool request_hardware,
630  bool resolve_indirect_symbols) {
631  BreakpointSP bp_sp;
632  if (filter_sp && resolver_sp) {
633  const bool hardware = request_hardware || GetRequireHardwareBreakpoints();
634  bp_sp.reset(new Breakpoint(*this, filter_sp, resolver_sp, hardware,
635  resolve_indirect_symbols));
636  resolver_sp->SetBreakpoint(bp_sp.get());
637  AddBreakpoint(bp_sp, internal);
638  }
639  return bp_sp;
640 }
641 
642 void Target::AddBreakpoint(lldb::BreakpointSP bp_sp, bool internal) {
643  if (!bp_sp)
644  return;
645  if (internal)
646  m_internal_breakpoint_list.Add(bp_sp, false);
647  else
648  m_breakpoint_list.Add(bp_sp, true);
649 
651  if (log) {
652  StreamString s;
653  bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
654  log->Printf("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__,
655  bp_sp->IsInternal() ? "yes" : "no", s.GetData());
656  }
657 
658  bp_sp->ResolveBreakpoint();
659 
660  if (!internal) {
662  }
663 }
664 
666  const char *name,
667  Status &error)
668  {
669  BreakpointSP bp_sp
670  = m_breakpoint_list.FindBreakpointByID(id.GetBreakpointID());
671  if (!bp_sp)
672  {
673  StreamString s;
674  id.GetDescription(&s, eDescriptionLevelBrief);
675  error.SetErrorStringWithFormat("Could not find breakpoint %s",
676  s.GetData());
677  return;
678  }
679  AddNameToBreakpoint(bp_sp, name, error);
680  }
681 
682 void Target::AddNameToBreakpoint(BreakpointSP &bp_sp,
683  const char *name,
684  Status &error)
685  {
686  if (!bp_sp)
687  return;
688 
689  BreakpointName *bp_name = FindBreakpointName(ConstString(name), true, error);
690  if (!bp_name)
691  return;
692 
693  bp_name->ConfigureBreakpoint(bp_sp);
694  bp_sp->AddName(name);
695  }
696 
698  m_breakpoint_names.insert(std::make_pair(bp_name->GetName(), bp_name));
699 }
700 
702  bool can_create,
703  Status &error)
704 {
706  if (!error.Success())
707  return nullptr;
708 
709  BreakpointNameList::iterator iter = m_breakpoint_names.find(name);
710  if (iter == m_breakpoint_names.end()) {
711  if (!can_create)
712  {
713  error.SetErrorStringWithFormat("Breakpoint name \"%s\" doesn't exist and "
714  "can_create is false.", name.AsCString());
715  return nullptr;
716  }
717 
718  iter = m_breakpoint_names.insert(std::make_pair(name,
719  new BreakpointName(name)))
720  .first;
721  }
722  return (iter->second);
723 }
724 
725 void
727 {
728  BreakpointNameList::iterator iter = m_breakpoint_names.find(name);
729 
730  if (iter != m_breakpoint_names.end()) {
731  const char *name_cstr = name.AsCString();
732  m_breakpoint_names.erase(iter);
733  for (auto bp_sp : m_breakpoint_list.Breakpoints())
734  bp_sp->RemoveName(name_cstr);
735  }
736 }
737 
738 void Target::RemoveNameFromBreakpoint(lldb::BreakpointSP &bp_sp,
739  ConstString name)
740 {
741  bp_sp->RemoveName(name.AsCString());
742 }
743 
745  const BreakpointOptions &new_options,
746  const BreakpointName::Permissions &new_permissions)
747 {
748  bp_name.GetOptions().CopyOverSetOptions(new_options);
749  bp_name.GetPermissions().MergeInto(new_permissions);
750  ApplyNameToBreakpoints(bp_name);
751 }
752 
754  BreakpointList bkpts_with_name(false);
756  bkpts_with_name);
757 
758  for (auto bp_sp : bkpts_with_name.Breakpoints())
759  bp_name.ConfigureBreakpoint(bp_sp);
760 }
761 
762 void Target::GetBreakpointNames(std::vector<std::string> &names)
763 {
764  names.clear();
765  for (auto bp_name : m_breakpoint_names) {
766  names.push_back(bp_name.first.AsCString());
767  }
768  llvm::sort(names.begin(), names.end());
769 }
770 
771 bool Target::ProcessIsValid() {
772  return (m_process_sp && m_process_sp->IsAlive());
773 }
774 
775 static bool CheckIfWatchpointsSupported(Target *target, Status &error) {
776  uint32_t num_supported_hardware_watchpoints;
777  Status rc = target->GetProcessSP()->GetWatchpointSupportInfo(
778  num_supported_hardware_watchpoints);
779 
780  // If unable to determine the # of watchpoints available,
781  // assume they are supported.
782  if (rc.Fail())
783  return true;
784 
785  if (num_supported_hardware_watchpoints == 0) {
787  "Target supports (%u) hardware watchpoint slots.\n",
788  num_supported_hardware_watchpoints);
789  return false;
790  }
791  return true;
792 }
793 
794 // See also Watchpoint::SetWatchpointType(uint32_t type) and the
795 // OptionGroupWatchpoint::WatchType enum type.
796 WatchpointSP Target::CreateWatchpoint(lldb::addr_t addr, size_t size,
797  const CompilerType *type, uint32_t kind,
798  Status &error) {
800  if (log)
801  log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64
802  " type = %u)\n",
803  __FUNCTION__, addr, (uint64_t)size, kind);
804 
805  WatchpointSP wp_sp;
806  if (!ProcessIsValid()) {
807  error.SetErrorString("process is not alive");
808  return wp_sp;
809  }
810 
811  if (addr == LLDB_INVALID_ADDRESS || size == 0) {
812  if (size == 0)
813  error.SetErrorString("cannot set a watchpoint with watch_size of 0");
814  else
815  error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr);
816  return wp_sp;
817  }
818 
819  if (!LLDB_WATCH_TYPE_IS_VALID(kind)) {
820  error.SetErrorStringWithFormat("invalid watchpoint type: %d", kind);
821  }
822 
823  if (!CheckIfWatchpointsSupported(this, error))
824  return wp_sp;
825 
826  // Currently we only support one watchpoint per address, with total number of
827  // watchpoints limited by the hardware which the inferior is running on.
828 
829  // Grab the list mutex while doing operations.
830  const bool notify = false; // Don't notify about all the state changes we do
831  // on creating the watchpoint.
832  std::unique_lock<std::recursive_mutex> lock;
833  this->GetWatchpointList().GetListMutex(lock);
834  WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr);
835  if (matched_sp) {
836  size_t old_size = matched_sp->GetByteSize();
837  uint32_t old_type =
838  (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) |
839  (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0);
840  // Return the existing watchpoint if both size and type match.
841  if (size == old_size && kind == old_type) {
842  wp_sp = matched_sp;
843  wp_sp->SetEnabled(false, notify);
844  } else {
845  // Nil the matched watchpoint; we will be creating a new one.
846  m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
847  m_watchpoint_list.Remove(matched_sp->GetID(), true);
848  }
849  }
850 
851  if (!wp_sp) {
852  wp_sp = std::make_shared<Watchpoint>(*this, addr, size, type);
853  wp_sp->SetWatchpointType(kind, notify);
854  m_watchpoint_list.Add(wp_sp, true);
855  }
856 
857  error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
858  if (log)
859  log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n",
860  __FUNCTION__, error.Success() ? "succeeded" : "failed",
861  wp_sp->GetID());
862 
863  if (error.Fail()) {
864  // Enabling the watchpoint on the device side failed. Remove the said
865  // watchpoint from the list maintained by the target instance.
866  m_watchpoint_list.Remove(wp_sp->GetID(), true);
867  // See if we could provide more helpful error message.
870  "watch size of %" PRIu64 " is not supported", (uint64_t)size);
871 
872  wp_sp.reset();
873  } else
875  return wp_sp;
876 }
877 
879 {
881  if (log)
882  log->Printf("Target::%s \n", __FUNCTION__);
883 
885 
887 }
888 
889 void Target::RemoveAllBreakpoints(bool internal_also) {
891  if (log)
892  log->Printf("Target::%s (internal_also = %s)\n", __FUNCTION__,
893  internal_also ? "yes" : "no");
894 
896  if (internal_also)
898 
900 }
901 
902 void Target::DisableAllBreakpoints(bool internal_also) {
904  if (log)
905  log->Printf("Target::%s (internal_also = %s)\n", __FUNCTION__,
906  internal_also ? "yes" : "no");
907 
909  if (internal_also)
911 }
912 
915  if (log)
916  log->Printf("Target::%s", __FUNCTION__);
917 
919 }
920 
921 void Target::EnableAllBreakpoints(bool internal_also) {
923  if (log)
924  log->Printf("Target::%s (internal_also = %s)\n", __FUNCTION__,
925  internal_also ? "yes" : "no");
926 
928  if (internal_also)
930 }
931 
934  if (log)
935  log->Printf("Target::%s", __FUNCTION__);
936 
938 }
939 
942  if (log)
943  log->Printf("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
944  break_id, LLDB_BREAK_ID_IS_INTERNAL(break_id) ? "yes" : "no");
945 
946  if (DisableBreakpointByID(break_id)) {
947  if (LLDB_BREAK_ID_IS_INTERNAL(break_id))
948  m_internal_breakpoint_list.Remove(break_id, false);
949  else {
951  if (m_last_created_breakpoint->GetID() == break_id)
953  }
954  m_breakpoint_list.Remove(break_id, true);
955  }
956  return true;
957  }
958  return false;
959 }
960 
963  if (log)
964  log->Printf("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
965  break_id, LLDB_BREAK_ID_IS_INTERNAL(break_id) ? "yes" : "no");
966 
967  BreakpointSP bp_sp;
968 
969  if (LLDB_BREAK_ID_IS_INTERNAL(break_id))
971  else
972  bp_sp = m_breakpoint_list.FindBreakpointByID(break_id);
973  if (bp_sp) {
974  bp_sp->SetEnabled(false);
975  return true;
976  }
977  return false;
978 }
979 
982  if (log)
983  log->Printf("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__,
984  break_id, LLDB_BREAK_ID_IS_INTERNAL(break_id) ? "yes" : "no");
985 
986  BreakpointSP bp_sp;
987 
988  if (LLDB_BREAK_ID_IS_INTERNAL(break_id))
990  else
991  bp_sp = m_breakpoint_list.FindBreakpointByID(break_id);
992 
993  if (bp_sp) {
994  bp_sp->SetEnabled(true);
995  return true;
996  }
997  return false;
998 }
999 
1001  const BreakpointIDList &bp_ids,
1002  bool append) {
1003  Status error;
1004 
1005  if (!file) {
1006  error.SetErrorString("Invalid FileSpec.");
1007  return error;
1008  }
1009 
1010  std::string path(file.GetPath());
1011  StructuredData::ObjectSP input_data_sp;
1012 
1013  StructuredData::ArraySP break_store_sp;
1014  StructuredData::Array *break_store_ptr = nullptr;
1015 
1016  if (append) {
1017  input_data_sp = StructuredData::ParseJSONFromFile(file, error);
1018  if (error.Success()) {
1019  break_store_ptr = input_data_sp->GetAsArray();
1020  if (!break_store_ptr) {
1022  "Tried to append to invalid input file %s", path.c_str());
1023  return error;
1024  }
1025  }
1026  }
1027 
1028  if (!break_store_ptr) {
1029  break_store_sp = std::make_shared<StructuredData::Array>();
1030  break_store_ptr = break_store_sp.get();
1031  }
1032 
1033  StreamFile out_file(path.c_str(),
1034  File::OpenOptions::eOpenOptionTruncate |
1035  File::OpenOptions::eOpenOptionWrite |
1036  File::OpenOptions::eOpenOptionCanCreate |
1037  File::OpenOptions::eOpenOptionCloseOnExec,
1038  lldb::eFilePermissionsFileDefault);
1039  if (!out_file.GetFile().IsValid()) {
1040  error.SetErrorStringWithFormat("Unable to open output file: %s.",
1041  path.c_str());
1042  return error;
1043  }
1044 
1045  std::unique_lock<std::recursive_mutex> lock;
1047 
1048  if (bp_ids.GetSize() == 0) {
1049  const BreakpointList &breakpoints = GetBreakpointList();
1050 
1051  size_t num_breakpoints = breakpoints.GetSize();
1052  for (size_t i = 0; i < num_breakpoints; i++) {
1053  Breakpoint *bp = breakpoints.GetBreakpointAtIndex(i).get();
1055  // If a breakpoint can't serialize it, just ignore it for now:
1056  if (bkpt_save_sp)
1057  break_store_ptr->AddItem(bkpt_save_sp);
1058  }
1059  } else {
1060 
1061  std::unordered_set<lldb::break_id_t> processed_bkpts;
1062  const size_t count = bp_ids.GetSize();
1063  for (size_t i = 0; i < count; ++i) {
1064  BreakpointID cur_bp_id = bp_ids.GetBreakpointIDAtIndex(i);
1065  lldb::break_id_t bp_id = cur_bp_id.GetBreakpointID();
1066 
1067  if (bp_id != LLDB_INVALID_BREAK_ID) {
1068  // Only do each breakpoint once:
1069  std::pair<std::unordered_set<lldb::break_id_t>::iterator, bool>
1070  insert_result = processed_bkpts.insert(bp_id);
1071  if (!insert_result.second)
1072  continue;
1073 
1074  Breakpoint *bp = GetBreakpointByID(bp_id).get();
1076  // If the user explicitly asked to serialize a breakpoint, and we
1077  // can't, then raise an error:
1078  if (!bkpt_save_sp) {
1079  error.SetErrorStringWithFormat("Unable to serialize breakpoint %d",
1080  bp_id);
1081  return error;
1082  }
1083  break_store_ptr->AddItem(bkpt_save_sp);
1084  }
1085  }
1086  }
1087 
1088  break_store_ptr->Dump(out_file, false);
1089  out_file.PutChar('\n');
1090  return error;
1091 }
1092 
1094  BreakpointIDList &new_bps) {
1095  std::vector<std::string> no_names;
1096  return CreateBreakpointsFromFile(file, no_names, new_bps);
1097 }
1098 
1100  std::vector<std::string> &names,
1101  BreakpointIDList &new_bps) {
1102  std::unique_lock<std::recursive_mutex> lock;
1104 
1105  Status error;
1106  StructuredData::ObjectSP input_data_sp =
1107  StructuredData::ParseJSONFromFile(file, error);
1108  if (!error.Success()) {
1109  return error;
1110  } else if (!input_data_sp || !input_data_sp->IsValid()) {
1111  error.SetErrorStringWithFormat("Invalid JSON from input file: %s.",
1112  file.GetPath().c_str());
1113  return error;
1114  }
1115 
1116  StructuredData::Array *bkpt_array = input_data_sp->GetAsArray();
1117  if (!bkpt_array) {
1119  "Invalid breakpoint data from input file: %s.", file.GetPath().c_str());
1120  return error;
1121  }
1122 
1123  size_t num_bkpts = bkpt_array->GetSize();
1124  size_t num_names = names.size();
1125 
1126  for (size_t i = 0; i < num_bkpts; i++) {
1127  StructuredData::ObjectSP bkpt_object_sp = bkpt_array->GetItemAtIndex(i);
1128  // Peel off the breakpoint key, and feed the rest to the Breakpoint:
1129  StructuredData::Dictionary *bkpt_dict = bkpt_object_sp->GetAsDictionary();
1130  if (!bkpt_dict) {
1132  "Invalid breakpoint data for element %zu from input file: %s.", i,
1133  file.GetPath().c_str());
1134  return error;
1135  }
1136  StructuredData::ObjectSP bkpt_data_sp =
1138  if (num_names &&
1139  !Breakpoint::SerializedBreakpointMatchesNames(bkpt_data_sp, names))
1140  continue;
1141 
1142  BreakpointSP bkpt_sp =
1143  Breakpoint::CreateFromStructuredData(*this, bkpt_data_sp, error);
1144  if (!error.Success()) {
1146  "Error restoring breakpoint %zu from %s: %s.", i,
1147  file.GetPath().c_str(), error.AsCString());
1148  return error;
1149  }
1150  new_bps.AddBreakpointID(BreakpointID(bkpt_sp->GetID()));
1151  }
1152  return error;
1153 }
1154 
1155 // The flag 'end_to_end', default to true, signifies that the operation is
1156 // performed end to end, for both the debugger and the debuggee.
1157 
1158 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
1159 // to end operations.
1160 bool Target::RemoveAllWatchpoints(bool end_to_end) {
1162  if (log)
1163  log->Printf("Target::%s\n", __FUNCTION__);
1164 
1165  if (!end_to_end) {
1167  return true;
1168  }
1169 
1170  // Otherwise, it's an end to end operation.
1171 
1172  if (!ProcessIsValid())
1173  return false;
1174 
1175  size_t num_watchpoints = m_watchpoint_list.GetSize();
1176  for (size_t i = 0; i < num_watchpoints; ++i) {
1177  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1178  if (!wp_sp)
1179  return false;
1180 
1181  Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
1182  if (rc.Fail())
1183  return false;
1184  }
1186  m_last_created_watchpoint.reset();
1187  return true; // Success!
1188 }
1189 
1190 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
1191 // to end operations.
1192 bool Target::DisableAllWatchpoints(bool end_to_end) {
1194  if (log)
1195  log->Printf("Target::%s\n", __FUNCTION__);
1196 
1197  if (!end_to_end) {
1199  return true;
1200  }
1201 
1202  // Otherwise, it's an end to end operation.
1203 
1204  if (!ProcessIsValid())
1205  return false;
1206 
1207  size_t num_watchpoints = m_watchpoint_list.GetSize();
1208  for (size_t i = 0; i < num_watchpoints; ++i) {
1209  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1210  if (!wp_sp)
1211  return false;
1212 
1213  Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
1214  if (rc.Fail())
1215  return false;
1216  }
1217  return true; // Success!
1218 }
1219 
1220 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
1221 // to end operations.
1222 bool Target::EnableAllWatchpoints(bool end_to_end) {
1224  if (log)
1225  log->Printf("Target::%s\n", __FUNCTION__);
1226 
1227  if (!end_to_end) {
1229  return true;
1230  }
1231 
1232  // Otherwise, it's an end to end operation.
1233 
1234  if (!ProcessIsValid())
1235  return false;
1236 
1237  size_t num_watchpoints = m_watchpoint_list.GetSize();
1238  for (size_t i = 0; i < num_watchpoints; ++i) {
1239  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1240  if (!wp_sp)
1241  return false;
1242 
1243  Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
1244  if (rc.Fail())
1245  return false;
1246  }
1247  return true; // Success!
1248 }
1249 
1250 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1253  if (log)
1254  log->Printf("Target::%s\n", __FUNCTION__);
1255 
1256  size_t num_watchpoints = m_watchpoint_list.GetSize();
1257  for (size_t i = 0; i < num_watchpoints; ++i) {
1258  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1259  if (!wp_sp)
1260  return false;
1261 
1262  wp_sp->ResetHitCount();
1263  }
1264  return true; // Success!
1265 }
1266 
1267 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1270  if (log)
1271  log->Printf("Target::%s\n", __FUNCTION__);
1272 
1273  size_t num_watchpoints = m_watchpoint_list.GetSize();
1274  for (size_t i = 0; i < num_watchpoints; ++i) {
1275  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1276  if (!wp_sp)
1277  return false;
1278 
1279  wp_sp->ResetHistoricValues();
1280  }
1281  return true; // Success!
1282 }
1283 
1284 // Assumption: Caller holds the list mutex lock for m_watchpoint_list during
1285 // these operations.
1288  if (log)
1289  log->Printf("Target::%s\n", __FUNCTION__);
1290 
1291  if (!ProcessIsValid())
1292  return false;
1293 
1294  size_t num_watchpoints = m_watchpoint_list.GetSize();
1295  for (size_t i = 0; i < num_watchpoints; ++i) {
1296  WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
1297  if (!wp_sp)
1298  return false;
1299 
1300  wp_sp->SetIgnoreCount(ignore_count);
1301  }
1302  return true; // Success!
1303 }
1304 
1305 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1308  if (log)
1309  log->Printf("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1310 
1311  if (!ProcessIsValid())
1312  return false;
1313 
1314  WatchpointSP wp_sp = m_watchpoint_list.FindByID(watch_id);
1315  if (wp_sp) {
1316  Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
1317  if (rc.Success())
1318  return true;
1319 
1320  // Else, fallthrough.
1321  }
1322  return false;
1323 }
1324 
1325 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1328  if (log)
1329  log->Printf("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1330 
1331  if (!ProcessIsValid())
1332  return false;
1333 
1334  WatchpointSP wp_sp = m_watchpoint_list.FindByID(watch_id);
1335  if (wp_sp) {
1336  Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
1337  if (rc.Success())
1338  return true;
1339 
1340  // Else, fallthrough.
1341  }
1342  return false;
1343 }
1344 
1345 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1348  if (log)
1349  log->Printf("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1350 
1351  WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id);
1352  if (watch_to_remove_sp == m_last_created_watchpoint)
1353  m_last_created_watchpoint.reset();
1354 
1355  if (DisableWatchpointByID(watch_id)) {
1356  m_watchpoint_list.Remove(watch_id, true);
1357  return true;
1358  }
1359  return false;
1360 }
1361 
1362 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
1364  uint32_t ignore_count) {
1366  if (log)
1367  log->Printf("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
1368 
1369  if (!ProcessIsValid())
1370  return false;
1371 
1372  WatchpointSP wp_sp = m_watchpoint_list.FindByID(watch_id);
1373  if (wp_sp) {
1374  wp_sp->SetIgnoreCount(ignore_count);
1375  return true;
1376  }
1377  return false;
1378 }
1379 
1381  // search for the first executable in the module list
1382  for (size_t i = 0; i < m_images.GetSize(); ++i) {
1383  ModuleSP module_sp = m_images.GetModuleAtIndex(i);
1384  lldb_private::ObjectFile *obj = module_sp->GetObjectFile();
1385  if (obj == nullptr)
1386  continue;
1387  if (obj->GetType() == ObjectFile::Type::eTypeExecutable)
1388  return module_sp;
1389  }
1390  // as fall back return the first module loaded
1391  return m_images.GetModuleAtIndex(0);
1392 }
1393 
1395  return GetExecutableModule().get();
1396 }
1397 
1398 static void LoadScriptingResourceForModule(const ModuleSP &module_sp,
1399  Target *target) {
1400  Status error;
1401  StreamString feedback_stream;
1402  if (module_sp &&
1403  !module_sp->LoadScriptingResourceInTarget(target, error,
1404  &feedback_stream)) {
1405  if (error.AsCString())
1406  target->GetDebugger().GetErrorFile()->Printf(
1407  "unable to load scripting data for module %s - error reported was "
1408  "%s\n",
1409  module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1410  error.AsCString());
1411  }
1412  if (feedback_stream.GetSize())
1413  target->GetDebugger().GetErrorFile()->Printf("%s\n",
1414  feedback_stream.GetData());
1415 }
1416 
1417 void Target::ClearModules(bool delete_locations) {
1418  ModulesDidUnload(m_images, delete_locations);
1420  m_images.Clear();
1422  m_ast_importer_sp.reset();
1423 }
1424 
1426  // When a process exec's we need to know about it so we can do some cleanup.
1429 }
1430 
1431 void Target::SetExecutableModule(ModuleSP &executable_sp,
1432  LoadDependentFiles load_dependent_files) {
1434  ClearModules(false);
1435 
1436  if (executable_sp) {
1437  static Timer::Category func_cat(LLVM_PRETTY_FUNCTION);
1438  Timer scoped_timer(func_cat,
1439  "Target::SetExecutableModule (executable = '%s')",
1440  executable_sp->GetFileSpec().GetPath().c_str());
1441 
1442  const bool notify = true;
1443  m_images.Append(executable_sp, notify); // The first image is our executable file
1444 
1445  // If we haven't set an architecture yet, reset our architecture based on
1446  // what we found in the executable module.
1447  if (!m_arch.GetSpec().IsValid()) {
1448  m_arch = executable_sp->GetArchitecture();
1449  LLDB_LOG(log,
1450  "setting architecture to {0} ({1}) based on executable file",
1452  m_arch.GetSpec().GetTriple().getTriple());
1453  }
1454 
1455  FileSpecList dependent_files;
1456  ObjectFile *executable_objfile = executable_sp->GetObjectFile();
1457  bool load_dependents = true;
1458  switch (load_dependent_files) {
1460  load_dependents = executable_sp->IsExecutable();
1461  break;
1462  case eLoadDependentsYes:
1463  load_dependents = true;
1464  break;
1465  case eLoadDependentsNo:
1466  load_dependents = false;
1467  break;
1468  }
1469 
1470  if (executable_objfile && load_dependents) {
1471  ModuleList added_modules;
1472  executable_objfile->GetDependentModules(dependent_files);
1473  for (uint32_t i = 0; i < dependent_files.GetSize(); i++) {
1474  FileSpec dependent_file_spec(
1475  dependent_files.GetFileSpecPointerAtIndex(i));
1476  FileSpec platform_dependent_file_spec;
1477  if (m_platform_sp)
1478  m_platform_sp->GetFileWithUUID(dependent_file_spec, nullptr,
1479  platform_dependent_file_spec);
1480  else
1481  platform_dependent_file_spec = dependent_file_spec;
1482 
1483  ModuleSpec module_spec(platform_dependent_file_spec, m_arch.GetSpec());
1484  ModuleSP image_module_sp(GetOrCreateModule(module_spec,
1485  false /* notify */));
1486  if (image_module_sp) {
1487  added_modules.AppendIfNeeded (image_module_sp, false);
1488  ObjectFile *objfile = image_module_sp->GetObjectFile();
1489  if (objfile)
1490  objfile->GetDependentModules(dependent_files);
1491  }
1492  }
1493  ModulesDidLoad(added_modules);
1494  }
1495  }
1496 }
1497 
1498 bool Target::SetArchitecture(const ArchSpec &arch_spec, bool set_platform) {
1500  bool missing_local_arch = !m_arch.GetSpec().IsValid();
1501  bool replace_local_arch = true;
1502  bool compatible_local_arch = false;
1503  ArchSpec other(arch_spec);
1504 
1505  // Changing the architecture might mean that the currently selected platform
1506  // isn't compatible. Set the platform correctly if we are asked to do so,
1507  // otherwise assume the user will set the platform manually.
1508  if (set_platform) {
1509  if (other.IsValid()) {
1510  auto platform_sp = GetPlatform();
1511  if (!platform_sp ||
1512  !platform_sp->IsCompatibleArchitecture(other, false, nullptr)) {
1513  ArchSpec platform_arch;
1514  auto arch_platform_sp =
1515  Platform::GetPlatformForArchitecture(other, &platform_arch);
1516  if (arch_platform_sp) {
1517  SetPlatform(arch_platform_sp);
1518  if (platform_arch.IsValid())
1519  other = platform_arch;
1520  }
1521  }
1522  }
1523  }
1524 
1525  if (!missing_local_arch) {
1526  if (m_arch.GetSpec().IsCompatibleMatch(arch_spec)) {
1527  other.MergeFrom(m_arch.GetSpec());
1528 
1529  if (m_arch.GetSpec().IsCompatibleMatch(other)) {
1530  compatible_local_arch = true;
1531  bool arch_changed, vendor_changed, os_changed, os_ver_changed,
1532  env_changed;
1533 
1534  m_arch.GetSpec().PiecewiseTripleCompare(other, arch_changed, vendor_changed,
1535  os_changed, os_ver_changed, env_changed);
1536 
1537  if (!arch_changed && !vendor_changed && !os_changed && !env_changed)
1538  replace_local_arch = false;
1539  }
1540  }
1541  }
1542 
1543  if (compatible_local_arch || missing_local_arch) {
1544  // If we haven't got a valid arch spec, or the architectures are compatible
1545  // update the architecture, unless the one we already have is more
1546  // specified
1547  if (replace_local_arch)
1548  m_arch = other;
1549  LLDB_LOG(log, "set architecture to {0} ({1})",
1551  m_arch.GetSpec().GetTriple().getTriple());
1552  return true;
1553  }
1554 
1555  // If we have an executable file, try to reset the executable to the desired
1556  // architecture
1557  if (log)
1558  log->Printf("Target::SetArchitecture changing architecture to %s (%s)",
1559  arch_spec.GetArchitectureName(),
1560  arch_spec.GetTriple().getTriple().c_str());
1561  m_arch = other;
1562  ModuleSP executable_sp = GetExecutableModule();
1563 
1564  ClearModules(true);
1565  // Need to do something about unsetting breakpoints.
1566 
1567  if (executable_sp) {
1568  if (log)
1569  log->Printf("Target::SetArchitecture Trying to select executable file "
1570  "architecture %s (%s)",
1571  arch_spec.GetArchitectureName(),
1572  arch_spec.GetTriple().getTriple().c_str());
1573  ModuleSpec module_spec(executable_sp->GetFileSpec(), other);
1574  FileSpecList search_paths = GetExecutableSearchPaths();
1575  Status error = ModuleList::GetSharedModule(module_spec, executable_sp,
1576  &search_paths,
1577  nullptr, nullptr);
1578 
1579  if (!error.Fail() && executable_sp) {
1580  SetExecutableModule(executable_sp, eLoadDependentsYes);
1581  return true;
1582  }
1583  }
1584  return false;
1585 }
1586 
1587 bool Target::MergeArchitecture(const ArchSpec &arch_spec) {
1589  if (arch_spec.IsValid()) {
1590  if (m_arch.GetSpec().IsCompatibleMatch(arch_spec)) {
1591  // The current target arch is compatible with "arch_spec", see if we can
1592  // improve our current architecture using bits from "arch_spec"
1593 
1594  if (log)
1595  log->Printf("Target::MergeArchitecture target has arch %s, merging with "
1596  "arch %s",
1597  m_arch.GetSpec().GetTriple().getTriple().c_str(),
1598  arch_spec.GetTriple().getTriple().c_str());
1599 
1600  // Merge bits from arch_spec into "merged_arch" and set our architecture
1601  ArchSpec merged_arch(m_arch.GetSpec());
1602  merged_arch.MergeFrom(arch_spec);
1603  return SetArchitecture(merged_arch);
1604  } else {
1605  // The new architecture is different, we just need to replace it
1606  return SetArchitecture(arch_spec);
1607  }
1608  }
1609  return false;
1610 }
1611 
1612 void Target::NotifyWillClearList(const ModuleList &module_list) {}
1613 
1614 void Target::NotifyModuleAdded(const ModuleList &module_list,
1615  const ModuleSP &module_sp) {
1616  // A module is being added to this target for the first time
1617  if (m_valid) {
1618  ModuleList my_module_list;
1619  my_module_list.Append(module_sp);
1620  ModulesDidLoad(my_module_list);
1621  }
1622 }
1623 
1624 void Target::NotifyModuleRemoved(const ModuleList &module_list,
1625  const ModuleSP &module_sp) {
1626  // A module is being removed from this target.
1627  if (m_valid) {
1628  ModuleList my_module_list;
1629  my_module_list.Append(module_sp);
1630  ModulesDidUnload(my_module_list, false);
1631  }
1632 }
1633 
1634 void Target::NotifyModuleUpdated(const ModuleList &module_list,
1635  const ModuleSP &old_module_sp,
1636  const ModuleSP &new_module_sp) {
1637  // A module is replacing an already added module
1638  if (m_valid) {
1640  new_module_sp);
1642  old_module_sp, new_module_sp);
1643  }
1644 }
1645 
1647  ModulesDidUnload (module_list, false);
1648 }
1649 
1650 
1652  const size_t num_images = module_list.GetSize();
1653  if (m_valid && num_images) {
1654  for (size_t idx = 0; idx < num_images; ++idx) {
1655  ModuleSP module_sp(module_list.GetModuleAtIndex(idx));
1656  LoadScriptingResourceForModule(module_sp, this);
1657  }
1658  m_breakpoint_list.UpdateBreakpoints(module_list, true, false);
1659  m_internal_breakpoint_list.UpdateBreakpoints(module_list, true, false);
1660  if (m_process_sp) {
1661  m_process_sp->ModulesDidLoad(module_list);
1662  }
1664  new TargetEventData(this->shared_from_this(), module_list));
1665  }
1666 }
1667 
1669  if (m_valid && module_list.GetSize()) {
1670  if (m_process_sp) {
1671  LanguageRuntime *runtime =
1672  m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
1673  if (runtime) {
1674  ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime *)runtime;
1675  objc_runtime->SymbolsDidLoad(module_list);
1676  }
1677  }
1678 
1679  m_breakpoint_list.UpdateBreakpoints(module_list, true, false);
1680  m_internal_breakpoint_list.UpdateBreakpoints(module_list, true, false);
1682  new TargetEventData(this->shared_from_this(), module_list));
1683  }
1684 }
1685 
1686 void Target::ModulesDidUnload(ModuleList &module_list, bool delete_locations) {
1687  if (m_valid && module_list.GetSize()) {
1688  UnloadModuleSections(module_list);
1689  m_breakpoint_list.UpdateBreakpoints(module_list, false, delete_locations);
1690  m_internal_breakpoint_list.UpdateBreakpoints(module_list, false,
1691  delete_locations);
1693  new TargetEventData(this->shared_from_this(), module_list));
1694  }
1695 }
1696 
1698  const FileSpec &module_file_spec) {
1700  ModuleList matchingModules;
1701  ModuleSpec module_spec(module_file_spec);
1702  size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
1703 
1704  // If there is more than one module for this file spec, only return true if
1705  // ALL the modules are on the
1706  // black list.
1707  if (num_modules > 0) {
1708  for (size_t i = 0; i < num_modules; i++) {
1710  matchingModules.GetModuleAtIndex(i)))
1711  return false;
1712  }
1713  return true;
1714  }
1715  }
1716  return false;
1717 }
1718 
1720  const lldb::ModuleSP &module_sp) {
1722  if (m_platform_sp)
1723  return m_platform_sp->ModuleIsExcludedForUnconstrainedSearches(*this,
1724  module_sp);
1725  }
1726  return false;
1727 }
1728 
1729 size_t Target::ReadMemoryFromFileCache(const Address &addr, void *dst,
1730  size_t dst_len, Status &error) {
1731  SectionSP section_sp(addr.GetSection());
1732  if (section_sp) {
1733  // If the contents of this section are encrypted, the on-disk file is
1734  // unusable. Read only from live memory.
1735  if (section_sp->IsEncrypted()) {
1736  error.SetErrorString("section is encrypted");
1737  return 0;
1738  }
1739  ModuleSP module_sp(section_sp->GetModule());
1740  if (module_sp) {
1741  ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
1742  if (objfile) {
1743  size_t bytes_read = objfile->ReadSectionData(
1744  section_sp.get(), addr.GetOffset(), dst, dst_len);
1745  if (bytes_read > 0)
1746  return bytes_read;
1747  else
1748  error.SetErrorStringWithFormat("error reading data from section %s",
1749  section_sp->GetName().GetCString());
1750  } else
1751  error.SetErrorString("address isn't from a object file");
1752  } else
1753  error.SetErrorString("address isn't in a module");
1754  } else
1755  error.SetErrorString("address doesn't contain a section that points to a "
1756  "section in a object file");
1757 
1758  return 0;
1759 }
1760 
1761 size_t Target::ReadMemory(const Address &addr, bool prefer_file_cache,
1762  void *dst, size_t dst_len, Status &error,
1763  lldb::addr_t *load_addr_ptr) {
1764  error.Clear();
1765 
1766  // if we end up reading this from process memory, we will fill this with the
1767  // actual load address
1768  if (load_addr_ptr)
1769  *load_addr_ptr = LLDB_INVALID_ADDRESS;
1770 
1771  size_t bytes_read = 0;
1772 
1773  addr_t load_addr = LLDB_INVALID_ADDRESS;
1774  addr_t file_addr = LLDB_INVALID_ADDRESS;
1775  Address resolved_addr;
1776  if (!addr.IsSectionOffset()) {
1777  SectionLoadList &section_load_list = GetSectionLoadList();
1778  if (section_load_list.IsEmpty()) {
1779  // No sections are loaded, so we must assume we are not running yet and
1780  // anything we are given is a file address.
1781  file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its
1782  // offset is the file address
1783  m_images.ResolveFileAddress(file_addr, resolved_addr);
1784  } else {
1785  // We have at least one section loaded. This can be because we have
1786  // manually loaded some sections with "target modules load ..." or
1787  // because we have have a live process that has sections loaded through
1788  // the dynamic loader
1789  load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its
1790  // offset is the load address
1791  section_load_list.ResolveLoadAddress(load_addr, resolved_addr);
1792  }
1793  }
1794  if (!resolved_addr.IsValid())
1795  resolved_addr = addr;
1796 
1797  if (prefer_file_cache) {
1798  bytes_read = ReadMemoryFromFileCache(resolved_addr, dst, dst_len, error);
1799  if (bytes_read > 0)
1800  return bytes_read;
1801  }
1802 
1803  if (ProcessIsValid()) {
1804  if (load_addr == LLDB_INVALID_ADDRESS)
1805  load_addr = resolved_addr.GetLoadAddress(this);
1806 
1807  if (load_addr == LLDB_INVALID_ADDRESS) {
1808  ModuleSP addr_module_sp(resolved_addr.GetModule());
1809  if (addr_module_sp && addr_module_sp->GetFileSpec())
1811  "{0:F}[{1:x+}] can't be resolved, {0:F} is not currently loaded",
1812  addr_module_sp->GetFileSpec(), resolved_addr.GetFileAddress());
1813  else
1814  error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved",
1815  resolved_addr.GetFileAddress());
1816  } else {
1817  bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error);
1818  if (bytes_read != dst_len) {
1819  if (error.Success()) {
1820  if (bytes_read == 0)
1822  "read memory from 0x%" PRIx64 " failed", load_addr);
1823  else
1825  "only %" PRIu64 " of %" PRIu64
1826  " bytes were read from memory at 0x%" PRIx64,
1827  (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
1828  }
1829  }
1830  if (bytes_read) {
1831  if (load_addr_ptr)
1832  *load_addr_ptr = load_addr;
1833  return bytes_read;
1834  }
1835  // If the address is not section offset we have an address that doesn't
1836  // resolve to any address in any currently loaded shared libraries and we
1837  // failed to read memory so there isn't anything more we can do. If it is
1838  // section offset, we might be able to read cached memory from the object
1839  // file.
1840  if (!resolved_addr.IsSectionOffset())
1841  return 0;
1842  }
1843  }
1844 
1845  if (!prefer_file_cache && resolved_addr.IsSectionOffset()) {
1846  // If we didn't already try and read from the object file cache, then try
1847  // it after failing to read from the process.
1848  return ReadMemoryFromFileCache(resolved_addr, dst, dst_len, error);
1849  }
1850  return 0;
1851 }
1852 
1853 size_t Target::ReadCStringFromMemory(const Address &addr, std::string &out_str,
1854  Status &error) {
1855  char buf[256];
1856  out_str.clear();
1857  addr_t curr_addr = addr.GetLoadAddress(this);
1858  Address address(addr);
1859  while (1) {
1860  size_t length = ReadCStringFromMemory(address, buf, sizeof(buf), error);
1861  if (length == 0)
1862  break;
1863  out_str.append(buf, length);
1864  // If we got "length - 1" bytes, we didn't get the whole C string, we need
1865  // to read some more characters
1866  if (length == sizeof(buf) - 1)
1867  curr_addr += length;
1868  else
1869  break;
1870  address = Address(curr_addr);
1871  }
1872  return out_str.size();
1873 }
1874 
1875 size_t Target::ReadCStringFromMemory(const Address &addr, char *dst,
1876  size_t dst_max_len, Status &result_error) {
1877  size_t total_cstr_len = 0;
1878  if (dst && dst_max_len) {
1879  result_error.Clear();
1880  // NULL out everything just to be safe
1881  memset(dst, 0, dst_max_len);
1882  Status error;
1883  addr_t curr_addr = addr.GetLoadAddress(this);
1884  Address address(addr);
1885 
1886  // We could call m_process_sp->GetMemoryCacheLineSize() but I don't think
1887  // this really needs to be tied to the memory cache subsystem's cache line
1888  // size, so leave this as a fixed constant.
1889  const size_t cache_line_size = 512;
1890 
1891  size_t bytes_left = dst_max_len - 1;
1892  char *curr_dst = dst;
1893 
1894  while (bytes_left > 0) {
1895  addr_t cache_line_bytes_left =
1896  cache_line_size - (curr_addr % cache_line_size);
1897  addr_t bytes_to_read =
1898  std::min<addr_t>(bytes_left, cache_line_bytes_left);
1899  size_t bytes_read =
1900  ReadMemory(address, false, curr_dst, bytes_to_read, error);
1901 
1902  if (bytes_read == 0) {
1903  result_error = error;
1904  dst[total_cstr_len] = '\0';
1905  break;
1906  }
1907  const size_t len = strlen(curr_dst);
1908 
1909  total_cstr_len += len;
1910 
1911  if (len < bytes_to_read)
1912  break;
1913 
1914  curr_dst += bytes_read;
1915  curr_addr += bytes_read;
1916  bytes_left -= bytes_read;
1917  address = Address(curr_addr);
1918  }
1919  } else {
1920  if (dst == nullptr)
1921  result_error.SetErrorString("invalid arguments");
1922  else
1923  result_error.Clear();
1924  }
1925  return total_cstr_len;
1926 }
1927 
1929  bool prefer_file_cache,
1930  uint32_t byte_size, bool is_signed,
1931  Scalar &scalar, Status &error) {
1932  uint64_t uval;
1933 
1934  if (byte_size <= sizeof(uval)) {
1935  size_t bytes_read =
1936  ReadMemory(addr, prefer_file_cache, &uval, byte_size, error);
1937  if (bytes_read == byte_size) {
1938  DataExtractor data(&uval, sizeof(uval), m_arch.GetSpec().GetByteOrder(),
1940  lldb::offset_t offset = 0;
1941  if (byte_size <= 4)
1942  scalar = data.GetMaxU32(&offset, byte_size);
1943  else
1944  scalar = data.GetMaxU64(&offset, byte_size);
1945 
1946  if (is_signed)
1947  scalar.SignExtend(byte_size * 8);
1948  return bytes_read;
1949  }
1950  } else {
1952  "byte size of %u is too large for integer scalar type", byte_size);
1953  }
1954  return 0;
1955 }
1956 
1958  bool prefer_file_cache,
1959  size_t integer_byte_size,
1960  uint64_t fail_value,
1961  Status &error) {
1962  Scalar scalar;
1963  if (ReadScalarIntegerFromMemory(addr, prefer_file_cache, integer_byte_size,
1964  false, scalar, error))
1965  return scalar.ULongLong(fail_value);
1966  return fail_value;
1967 }
1968 
1969 bool Target::ReadPointerFromMemory(const Address &addr, bool prefer_file_cache,
1970  Status &error, Address &pointer_addr) {
1971  Scalar scalar;
1972  if (ReadScalarIntegerFromMemory(addr, prefer_file_cache,
1973  m_arch.GetSpec().GetAddressByteSize(), false, scalar,
1974  error)) {
1975  addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1976  if (pointer_vm_addr != LLDB_INVALID_ADDRESS) {
1977  SectionLoadList &section_load_list = GetSectionLoadList();
1978  if (section_load_list.IsEmpty()) {
1979  // No sections are loaded, so we must assume we are not running yet and
1980  // anything we are given is a file address.
1981  m_images.ResolveFileAddress(pointer_vm_addr, pointer_addr);
1982  } else {
1983  // We have at least one section loaded. This can be because we have
1984  // manually loaded some sections with "target modules load ..." or
1985  // because we have have a live process that has sections loaded through
1986  // the dynamic loader
1987  section_load_list.ResolveLoadAddress(pointer_vm_addr, pointer_addr);
1988  }
1989  // We weren't able to resolve the pointer value, so just return an
1990  // address with no section
1991  if (!pointer_addr.IsValid())
1992  pointer_addr.SetOffset(pointer_vm_addr);
1993  return true;
1994  }
1995  }
1996  return false;
1997 }
1998 
1999 ModuleSP Target::GetOrCreateModule(const ModuleSpec &module_spec, bool notify,
2000  Status *error_ptr) {
2001  ModuleSP module_sp;
2002 
2003  Status error;
2004 
2005  // First see if we already have this module in our module list. If we do,
2006  // then we're done, we don't need to consult the shared modules list. But
2007  // only do this if we are passed a UUID.
2008 
2009  if (module_spec.GetUUID().IsValid())
2010  module_sp = m_images.FindFirstModule(module_spec);
2011 
2012  if (!module_sp) {
2013  ModuleSP old_module_sp; // This will get filled in if we have a new version
2014  // of the library
2015  bool did_create_module = false;
2016  FileSpecList search_paths = GetExecutableSearchPaths();
2017  // If there are image search path entries, try to use them first to acquire
2018  // a suitable image.
2019  if (m_image_search_paths.GetSize()) {
2020  ModuleSpec transformed_spec(module_spec);
2022  module_spec.GetFileSpec().GetDirectory(),
2023  transformed_spec.GetFileSpec().GetDirectory())) {
2024  transformed_spec.GetFileSpec().GetFilename() =
2025  module_spec.GetFileSpec().GetFilename();
2026  error = ModuleList::GetSharedModule(transformed_spec, module_sp,
2027  &search_paths,
2028  &old_module_sp, &did_create_module);
2029  }
2030  }
2031 
2032  if (!module_sp) {
2033  // If we have a UUID, we can check our global shared module list in case
2034  // we already have it. If we don't have a valid UUID, then we can't since
2035  // the path in "module_spec" will be a platform path, and we will need to
2036  // let the platform find that file. For example, we could be asking for
2037  // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick
2038  // the local copy of "/usr/lib/dyld" since our platform could be a remote
2039  // platform that has its own "/usr/lib/dyld" in an SDK or in a local file
2040  // cache.
2041  if (module_spec.GetUUID().IsValid()) {
2042  // We have a UUID, it is OK to check the global module list...
2043  error = ModuleList::GetSharedModule(module_spec, module_sp,
2044  &search_paths,
2045  &old_module_sp, &did_create_module);
2046  }
2047 
2048  if (!module_sp) {
2049  // The platform is responsible for finding and caching an appropriate
2050  // module in the shared module cache.
2051  if (m_platform_sp) {
2052  error = m_platform_sp->GetSharedModule(
2053  module_spec, m_process_sp.get(), module_sp,
2054  &search_paths, &old_module_sp, &did_create_module);
2055  } else {
2056  error.SetErrorString("no platform is currently set");
2057  }
2058  }
2059  }
2060 
2061  // We found a module that wasn't in our target list. Let's make sure that
2062  // there wasn't an equivalent module in the list already, and if there was,
2063  // let's remove it.
2064  if (module_sp) {
2065  ObjectFile *objfile = module_sp->GetObjectFile();
2066  if (objfile) {
2067  switch (objfile->GetType()) {
2068  case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of
2069  /// a program's execution state
2070  case ObjectFile::eTypeExecutable: /// A normal executable
2071  case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker
2072  /// executable
2073  case ObjectFile::eTypeObjectFile: /// An intermediate object file
2074  case ObjectFile::eTypeSharedLibrary: /// A shared library that can be
2075  /// used during execution
2076  break;
2077  case ObjectFile::eTypeDebugInfo: /// An object file that contains only
2078  /// debug information
2079  if (error_ptr)
2080  error_ptr->SetErrorString("debug info files aren't valid target "
2081  "modules, please specify an executable");
2082  return ModuleSP();
2083  case ObjectFile::eTypeStubLibrary: /// A library that can be linked
2084  /// against but not used for
2085  /// execution
2086  if (error_ptr)
2087  error_ptr->SetErrorString("stub libraries aren't valid target "
2088  "modules, please specify an executable");
2089  return ModuleSP();
2090  default:
2091  if (error_ptr)
2092  error_ptr->SetErrorString(
2093  "unsupported file type, please specify an executable");
2094  return ModuleSP();
2095  }
2096  // GetSharedModule is not guaranteed to find the old shared module, for
2097  // instance in the common case where you pass in the UUID, it is only
2098  // going to find the one module matching the UUID. In fact, it has no
2099  // good way to know what the "old module" relevant to this target is,
2100  // since there might be many copies of a module with this file spec in
2101  // various running debug sessions, but only one of them will belong to
2102  // this target. So let's remove the UUID from the module list, and look
2103  // in the target's module list. Only do this if there is SOMETHING else
2104  // in the module spec...
2105  if (!old_module_sp) {
2106  if (module_spec.GetUUID().IsValid() &&
2107  !module_spec.GetFileSpec().GetFilename().IsEmpty() &&
2108  !module_spec.GetFileSpec().GetDirectory().IsEmpty()) {
2109  ModuleSpec module_spec_copy(module_spec.GetFileSpec());
2110  module_spec_copy.GetUUID().Clear();
2111 
2112  ModuleList found_modules;
2113  size_t num_found =
2114  m_images.FindModules(module_spec_copy, found_modules);
2115  if (num_found == 1) {
2116  old_module_sp = found_modules.GetModuleAtIndex(0);
2117  }
2118  }
2119  }
2120 
2121  // Preload symbols outside of any lock, so hopefully we can do this for
2122  // each library in parallel.
2123  if (GetPreloadSymbols())
2124  module_sp->PreloadSymbols();
2125 
2126  if (old_module_sp &&
2127  m_images.GetIndexForModule(old_module_sp.get()) !=
2129  m_images.ReplaceModule(old_module_sp, module_sp);
2130  Module *old_module_ptr = old_module_sp.get();
2131  old_module_sp.reset();
2133  } else {
2134  m_images.Append(module_sp, notify);
2135  }
2136  } else
2137  module_sp.reset();
2138  }
2139  }
2140  if (error_ptr)
2141  *error_ptr = error;
2142  return module_sp;
2143 }
2144 
2145 TargetSP Target::CalculateTarget() { return shared_from_this(); }
2146 
2148 
2149 ThreadSP Target::CalculateThread() { return ThreadSP(); }
2150 
2151 StackFrameSP Target::CalculateStackFrame() { return StackFrameSP(); }
2152 
2154  exe_ctx.Clear();
2155  exe_ctx.SetTargetPtr(this);
2156 }
2157 
2159  return m_image_search_paths;
2160 }
2161 
2163  void *baton) {
2164  Target *target = (Target *)baton;
2165  ModuleSP exe_module_sp(target->GetExecutableModule());
2166  if (exe_module_sp)
2167  target->SetExecutableModule(exe_module_sp, eLoadDependentsYes);
2168 }
2169 
2171  lldb::LanguageType language,
2172  bool create_on_demand) {
2173  if (!m_valid)
2174  return nullptr;
2175 
2176  if (error) {
2177  error->Clear();
2178  }
2179 
2180  if (language == eLanguageTypeMipsAssembler // GNU AS and LLVM use it for all
2181  // assembly code
2182  || language == eLanguageTypeUnknown) {
2183  std::set<lldb::LanguageType> languages_for_types;
2184  std::set<lldb::LanguageType> languages_for_expressions;
2185 
2186  Language::GetLanguagesSupportingTypeSystems(languages_for_types,
2187  languages_for_expressions);
2188 
2189  if (languages_for_expressions.count(eLanguageTypeC)) {
2190  language = eLanguageTypeC; // LLDB's default. Override by setting the
2191  // target language.
2192  } else {
2193  if (languages_for_expressions.empty()) {
2194  return nullptr;
2195  } else {
2196  language = *languages_for_expressions.begin();
2197  }
2198  }
2199  }
2200 
2202  create_on_demand);
2203 }
2204 
2207  TypeSystem *type_system =
2208  GetScratchTypeSystemForLanguage(nullptr, language, true);
2209 
2210  if (type_system) {
2211  return type_system->GetPersistentExpressionState();
2212  } else {
2213  return nullptr;
2214  }
2215 }
2216 
2218  llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language,
2219  Expression::ResultType desired_type,
2220  const EvaluateExpressionOptions &options,
2221  ValueObject *ctx_obj, Status &error) {
2222  Status type_system_error;
2223 
2224  TypeSystem *type_system =
2225  GetScratchTypeSystemForLanguage(&type_system_error, language);
2226  UserExpression *user_expr = nullptr;
2227 
2228  if (!type_system) {
2230  "Could not find type system for language %s: %s",
2232  type_system_error.AsCString());
2233  return nullptr;
2234  }
2235 
2236  user_expr = type_system->GetUserExpression(expr, prefix, language,
2237  desired_type, options, ctx_obj);
2238  if (!user_expr)
2240  "Could not create an expression for language %s",
2242 
2243  return user_expr;
2244 }
2245 
2247  lldb::LanguageType language, const CompilerType &return_type,
2248  const Address &function_address, const ValueList &arg_value_list,
2249  const char *name, Status &error) {
2250  Status type_system_error;
2251  TypeSystem *type_system =
2252  GetScratchTypeSystemForLanguage(&type_system_error, language);
2253  FunctionCaller *persistent_fn = nullptr;
2254 
2255  if (!type_system) {
2257  "Could not find type system for language %s: %s",
2259  type_system_error.AsCString());
2260  return persistent_fn;
2261  }
2262 
2263  persistent_fn = type_system->GetFunctionCaller(return_type, function_address,
2264  arg_value_list, name);
2265  if (!persistent_fn)
2267  "Could not create an expression for language %s",
2269 
2270  return persistent_fn;
2271 }
2272 
2275  lldb::LanguageType language,
2276  const char *name, Status &error) {
2277  Status type_system_error;
2278  TypeSystem *type_system =
2279  GetScratchTypeSystemForLanguage(&type_system_error, language);
2280  UtilityFunction *utility_fn = nullptr;
2281 
2282  if (!type_system) {
2284  "Could not find type system for language %s: %s",
2286  type_system_error.AsCString());
2287  return utility_fn;
2288  }
2289 
2290  utility_fn = type_system->GetUtilityFunction(text, name);
2291  if (!utility_fn)
2293  "Could not create an expression for language %s",
2295 
2296  return utility_fn;
2297 }
2298 
2300  if (m_valid) {
2301  if (TypeSystem *type_system = GetScratchTypeSystemForLanguage(
2302  nullptr, eLanguageTypeC, create_on_demand))
2303  return llvm::dyn_cast<ClangASTContext>(type_system);
2304  }
2305  return nullptr;
2306 }
2307 
2308 ClangASTImporterSP Target::GetClangASTImporter() {
2309  if (m_valid) {
2310  if (!m_ast_importer_sp) {
2311  m_ast_importer_sp = std::make_shared<ClangASTImporter>();
2312  }
2313  return m_ast_importer_sp;
2314  }
2315  return ClangASTImporterSP();
2316 }
2317 
2319 
2321 
2323  TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2324  if (properties_sp)
2325  return properties_sp->GetExecutableSearchPaths();
2326  return FileSpecList();
2327 }
2328 
2330  TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2331  if (properties_sp)
2332  return properties_sp->GetDebugFileSearchPaths();
2333  return FileSpecList();
2334 }
2335 
2337  TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2338  if (properties_sp)
2339  return properties_sp->GetClangModuleSearchPaths();
2340  return FileSpecList();
2341 }
2342 
2344  TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2345  if (properties_sp)
2346  return properties_sp->GetDefaultArchitecture();
2347  return ArchSpec();
2348 }
2349 
2351  TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
2352  if (properties_sp) {
2354  LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's "
2355  "default architecture to %s (%s)",
2356  arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str());
2357  return properties_sp->SetDefaultArchitecture(arch);
2358  }
2359 }
2360 
2362  const SymbolContext *sc_ptr) {
2363  // The target can either exist in the "process" of ExecutionContext, or in
2364  // the "target_sp" member of SymbolContext. This accessor helper function
2365  // will get the target from one of these locations.
2366 
2367  Target *target = nullptr;
2368  if (sc_ptr != nullptr)
2369  target = sc_ptr->target_sp.get();
2370  if (target == nullptr && exe_ctx_ptr)
2371  target = exe_ctx_ptr->GetTargetPtr();
2372  return target;
2373 }
2374 
2376  llvm::StringRef expr, ExecutionContextScope *exe_scope,
2377  lldb::ValueObjectSP &result_valobj_sp,
2378  const EvaluateExpressionOptions &options, std::string *fixed_expression,
2379  ValueObject *ctx_obj) {
2380  result_valobj_sp.reset();
2381 
2382  ExpressionResults execution_results = eExpressionSetupError;
2383 
2384  if (expr.empty())
2385  return execution_results;
2386 
2387  // We shouldn't run stop hooks in expressions. Be sure to reset this if you
2388  // return anywhere within this function.
2389  bool old_suppress_value = m_suppress_stop_hooks;
2390  m_suppress_stop_hooks = true;
2391 
2392  ExecutionContext exe_ctx;
2393 
2394  if (exe_scope) {
2395  exe_scope->CalculateExecutionContext(exe_ctx);
2396  } else if (m_process_sp) {
2397  m_process_sp->CalculateExecutionContext(exe_ctx);
2398  } else {
2399  CalculateExecutionContext(exe_ctx);
2400  }
2401 
2402  // Make sure we aren't just trying to see the value of a persistent variable
2403  // (something like "$0")
2404  lldb::ExpressionVariableSP persistent_var_sp;
2405  // Only check for persistent variables the expression starts with a '$'
2406  if (expr[0] == '$')
2407  persistent_var_sp = GetScratchTypeSystemForLanguage(nullptr, eLanguageTypeC)
2409  ->GetVariable(expr);
2410 
2411  if (persistent_var_sp) {
2412  result_valobj_sp = persistent_var_sp->GetValueObject();
2413  execution_results = eExpressionCompleted;
2414  } else {
2415  llvm::StringRef prefix = GetExpressionPrefixContents();
2416  Status error;
2417  execution_results =
2418  UserExpression::Evaluate(exe_ctx, options, expr, prefix,
2419  result_valobj_sp, error, fixed_expression,
2420  nullptr, // Module
2421  ctx_obj);
2422  }
2423 
2424  m_suppress_stop_hooks = old_suppress_value;
2425 
2426  return execution_results;
2427 }
2428 
2429 lldb::ExpressionVariableSP
2431  lldb::ExpressionVariableSP variable_sp;
2433  [name, &variable_sp](TypeSystem *type_system) -> bool {
2434  if (PersistentExpressionState *persistent_state =
2435  type_system->GetPersistentExpressionState()) {
2436  variable_sp = persistent_state->GetVariable(name);
2437 
2438  if (variable_sp)
2439  return false; // Stop iterating the ForEach
2440  }
2441  return true; // Keep iterating the ForEach
2442  });
2443  return variable_sp;
2444 }
2445 
2448 
2450  [name, &address](TypeSystem *type_system) -> bool {
2451  if (PersistentExpressionState *persistent_state =
2452  type_system->GetPersistentExpressionState()) {
2453  address = persistent_state->LookupSymbol(name);
2454  if (address != LLDB_INVALID_ADDRESS)
2455  return false; // Stop iterating the ForEach
2456  }
2457  return true; // Keep iterating the ForEach
2458  });
2459  return address;
2460 }
2461 
2463  AddressClass addr_class) const {
2464  auto arch_plugin = GetArchitecturePlugin();
2465  return arch_plugin ?
2466  arch_plugin->GetCallableLoadAddress(load_addr, addr_class) : load_addr;
2467 }
2468 
2470  AddressClass addr_class) const {
2471  auto arch_plugin = GetArchitecturePlugin();
2472  return arch_plugin ?
2473  arch_plugin->GetOpcodeLoadAddress(load_addr, addr_class) : load_addr;
2474 }
2475 
2477  auto arch_plugin = GetArchitecturePlugin();
2478  return arch_plugin ?
2479  arch_plugin->GetBreakableLoadAddress(addr, *this) : addr;
2480 }
2481 
2483  if (!m_source_manager_up)
2484  m_source_manager_up.reset(new SourceManager(shared_from_this()));
2485  return *m_source_manager_up;
2486 }
2487 
2489  static std::mutex s_clang_modules_decl_vendor_mutex; // If this is contended
2490  // we can make it
2491  // per-target
2492 
2493  {
2494  std::lock_guard<std::mutex> guard(s_clang_modules_decl_vendor_mutex);
2495 
2499  }
2500  }
2501 
2502  return m_clang_modules_decl_vendor_up.get();
2503 }
2504 
2507  Target::StopHookSP stop_hook_sp(new StopHook(shared_from_this(), new_uid));
2508  m_stop_hooks[new_uid] = stop_hook_sp;
2509  return stop_hook_sp;
2510 }
2511 
2513  size_t num_removed = m_stop_hooks.erase(user_id);
2514  return (num_removed != 0);
2515 }
2516 
2518 
2520  StopHookSP found_hook;
2521 
2522  StopHookCollection::iterator specified_hook_iter;
2523  specified_hook_iter = m_stop_hooks.find(user_id);
2524  if (specified_hook_iter != m_stop_hooks.end())
2525  found_hook = (*specified_hook_iter).second;
2526  return found_hook;
2527 }
2528 
2530  bool active_state) {
2531  StopHookCollection::iterator specified_hook_iter;
2532  specified_hook_iter = m_stop_hooks.find(user_id);
2533  if (specified_hook_iter == m_stop_hooks.end())
2534  return false;
2535 
2536  (*specified_hook_iter).second->SetIsActive(active_state);
2537  return true;
2538 }
2539 
2540 void Target::SetAllStopHooksActiveState(bool active_state) {
2541  StopHookCollection::iterator pos, end = m_stop_hooks.end();
2542  for (pos = m_stop_hooks.begin(); pos != end; pos++) {
2543  (*pos).second->SetIsActive(active_state);
2544  }
2545 }
2546 
2549  return;
2550 
2551  if (!m_process_sp)
2552  return;
2553 
2554  // Somebody might have restarted the process:
2555  if (m_process_sp->GetState() != eStateStopped)
2556  return;
2557 
2558  // <rdar://problem/12027563> make sure we check that we are not stopped
2559  // because of us running a user expression since in that case we do not want
2560  // to run the stop-hooks
2561  if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
2562  return;
2563 
2564  if (m_stop_hooks.empty())
2565  return;
2566 
2567  StopHookCollection::iterator pos, end = m_stop_hooks.end();
2568 
2569  // If there aren't any active stop hooks, don't bother either.
2570  // Also see if any of the active hooks want to auto-continue.
2571  bool any_active_hooks = false;
2572  bool auto_continue = false;
2573  for (auto hook : m_stop_hooks) {
2574  if (hook.second->IsActive()) {
2575  any_active_hooks = true;
2576  auto_continue |= hook.second->GetAutoContinue();
2577  }
2578  }
2579  if (!any_active_hooks)
2580  return;
2581 
2582  CommandReturnObject result;
2583 
2584  std::vector<ExecutionContext> exc_ctx_with_reasons;
2585  std::vector<SymbolContext> sym_ctx_with_reasons;
2586 
2587  ThreadList &cur_threadlist = m_process_sp->GetThreadList();
2588  size_t num_threads = cur_threadlist.GetSize();
2589  for (size_t i = 0; i < num_threads; i++) {
2590  lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex(i);
2591  if (cur_thread_sp->ThreadStoppedForAReason()) {
2592  lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
2593  exc_ctx_with_reasons.push_back(ExecutionContext(
2594  m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
2595  sym_ctx_with_reasons.push_back(
2596  cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
2597  }
2598  }
2599 
2600  // If no threads stopped for a reason, don't run the stop-hooks.
2601  size_t num_exe_ctx = exc_ctx_with_reasons.size();
2602  if (num_exe_ctx == 0)
2603  return;
2604 
2607 
2608  bool keep_going = true;
2609  bool hooks_ran = false;
2610  bool print_hook_header = (m_stop_hooks.size() != 1);
2611  bool print_thread_header = (num_exe_ctx != 1);
2612  bool did_restart = false;
2613 
2614  for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++) {
2615  // result.Clear();
2616  StopHookSP cur_hook_sp = (*pos).second;
2617  if (!cur_hook_sp->IsActive())
2618  continue;
2619 
2620  bool any_thread_matched = false;
2621  for (size_t i = 0; keep_going && i < num_exe_ctx; i++) {
2622  if ((cur_hook_sp->GetSpecifier() == nullptr ||
2623  cur_hook_sp->GetSpecifier()->SymbolContextMatches(
2624  sym_ctx_with_reasons[i])) &&
2625  (cur_hook_sp->GetThreadSpecifier() == nullptr ||
2626  cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(
2627  exc_ctx_with_reasons[i].GetThreadRef()))) {
2628  if (!hooks_ran) {
2629  hooks_ran = true;
2630  }
2631  if (print_hook_header && !any_thread_matched) {
2632  const char *cmd =
2633  (cur_hook_sp->GetCommands().GetSize() == 1
2634  ? cur_hook_sp->GetCommands().GetStringAtIndex(0)
2635  : nullptr);
2636  if (cmd)
2637  result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n",
2638  cur_hook_sp->GetID(), cmd);
2639  else
2640  result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n",
2641  cur_hook_sp->GetID());
2642  any_thread_matched = true;
2643  }
2644 
2645  if (print_thread_header)
2646  result.AppendMessageWithFormat(
2647  "-- Thread %d\n",
2648  exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID());
2649 
2651  options.SetStopOnContinue(true);
2652  options.SetStopOnError(true);
2653  options.SetEchoCommands(false);
2654  options.SetPrintResults(true);
2655  options.SetAddToHistory(false);
2656 
2657  // Force Async:
2658  bool old_async = GetDebugger().GetAsyncExecution();
2661  cur_hook_sp->GetCommands(), &exc_ctx_with_reasons[i], options,
2662  result);
2663  GetDebugger().SetAsyncExecution(old_async);
2664  // If the command started the target going again, we should bag out of
2665  // running the stop hooks.
2668  // But only complain if there were more stop hooks to do:
2669  StopHookCollection::iterator tmp = pos;
2670  if (++tmp != end)
2671  result.AppendMessageWithFormat("\nAborting stop hooks, hook %" PRIu64
2672  " set the program running.\n"
2673  " Consider using '-G true' to make "
2674  "stop hooks auto-continue.\n",
2675  cur_hook_sp->GetID());
2676  keep_going = false;
2677  did_restart = true;
2678  }
2679  }
2680  }
2681  }
2682  // Finally, if auto-continue was requested, do it now:
2683  if (!did_restart && auto_continue)
2684  m_process_sp->PrivateResume();
2685 
2686  result.GetImmediateOutputStream()->Flush();
2687  result.GetImmediateErrorStream()->Flush();
2688 }
2689 
2690 const TargetPropertiesSP &Target::GetGlobalProperties() {
2691  // NOTE: intentional leak so we don't crash if global destructor chain gets
2692  // called as other threads still use the result of this function
2693  static TargetPropertiesSP *g_settings_sp_ptr =
2694  new TargetPropertiesSP(new TargetProperties(nullptr));
2695  return *g_settings_sp_ptr;
2696 }
2697 
2699  Status error;
2700  PlatformSP platform_sp(GetPlatform());
2701  if (platform_sp) {
2702  if (platform_sp->IsRemote()) {
2703  if (platform_sp->IsConnected()) {
2704  // Install all files that have an install path, and always install the
2705  // main executable when connected to a remote platform
2706  const ModuleList &modules = GetImages();
2707  const size_t num_images = modules.GetSize();
2708  for (size_t idx = 0; idx < num_images; ++idx) {
2709  ModuleSP module_sp(modules.GetModuleAtIndex(idx));
2710  if (module_sp) {
2711  const bool is_main_executable = module_sp == GetExecutableModule();
2712  FileSpec local_file(module_sp->GetFileSpec());
2713  if (local_file) {
2714  FileSpec remote_file(module_sp->GetRemoteInstallFileSpec());
2715  if (!remote_file) {
2716  if (is_main_executable) // TODO: add setting for always
2717  // installing main executable???
2718  {
2719  // Always install the main executable
2720  remote_file = platform_sp->GetRemoteWorkingDirectory();
2721  remote_file.AppendPathComponent(
2722  module_sp->GetFileSpec().GetFilename().GetCString());
2723  }
2724  }
2725  if (remote_file) {
2726  error = platform_sp->Install(local_file, remote_file);
2727  if (error.Success()) {
2728  module_sp->SetPlatformFileSpec(remote_file);
2729  if (is_main_executable) {
2730  platform_sp->SetFilePermissions(remote_file, 0700);
2731  if (launch_info)
2732  launch_info->SetExecutableFile(remote_file, false);
2733  }
2734  } else
2735  break;
2736  }
2737  }
2738  }
2739  }
2740  }
2741  }
2742  }
2743  return error;
2744 }
2745 
2746 bool Target::ResolveLoadAddress(addr_t load_addr, Address &so_addr,
2747  uint32_t stop_id) {
2748  return m_section_load_history.ResolveLoadAddress(stop_id, load_addr, so_addr);
2749 }
2750 
2752  Address &resolved_addr) {
2753  return m_images.ResolveFileAddress(file_addr, resolved_addr);
2754 }
2755 
2756 bool Target::SetSectionLoadAddress(const SectionSP &section_sp,
2757  addr_t new_section_load_addr,
2758  bool warn_multiple) {
2759  const addr_t old_section_load_addr =
2761  SectionLoadHistory::eStopIDNow, section_sp);
2762  if (old_section_load_addr != new_section_load_addr) {
2763  uint32_t stop_id = 0;
2764  ProcessSP process_sp(GetProcessSP());
2765  if (process_sp)
2766  stop_id = process_sp->GetStopID();
2767  else
2770  stop_id, section_sp, new_section_load_addr, warn_multiple))
2771  return true; // Return true if the section load address was changed...
2772  }
2773  return false; // Return false to indicate nothing changed
2774 }
2775 
2776 size_t Target::UnloadModuleSections(const ModuleList &module_list) {
2777  size_t section_unload_count = 0;
2778  size_t num_modules = module_list.GetSize();
2779  for (size_t i = 0; i < num_modules; ++i) {
2780  section_unload_count +=
2781  UnloadModuleSections(module_list.GetModuleAtIndex(i));
2782  }
2783  return section_unload_count;
2784 }
2785 
2786 size_t Target::UnloadModuleSections(const lldb::ModuleSP &module_sp) {
2787  uint32_t stop_id = 0;
2788  ProcessSP process_sp(GetProcessSP());
2789  if (process_sp)
2790  stop_id = process_sp->GetStopID();
2791  else
2793  SectionList *sections = module_sp->GetSectionList();
2794  size_t section_unload_count = 0;
2795  if (sections) {
2796  const uint32_t num_sections = sections->GetNumSections(0);
2797  for (uint32_t i = 0; i < num_sections; ++i) {
2798  section_unload_count += m_section_load_history.SetSectionUnloaded(
2799  stop_id, sections->GetSectionAtIndex(i));
2800  }
2801  }
2802  return section_unload_count;
2803 }
2804 
2805 bool Target::SetSectionUnloaded(const lldb::SectionSP &section_sp) {
2806  uint32_t stop_id = 0;
2807  ProcessSP process_sp(GetProcessSP());
2808  if (process_sp)
2809  stop_id = process_sp->GetStopID();
2810  else
2812  return m_section_load_history.SetSectionUnloaded(stop_id, section_sp);
2813 }
2814 
2815 bool Target::SetSectionUnloaded(const lldb::SectionSP &section_sp,
2816  addr_t load_addr) {
2817  uint32_t stop_id = 0;
2818  ProcessSP process_sp(GetProcessSP());
2819  if (process_sp)
2820  stop_id = process_sp->GetStopID();
2821  else
2823  return m_section_load_history.SetSectionUnloaded(stop_id, section_sp,
2824  load_addr);
2825 }
2826 
2828 
2830  Status error;
2832 
2833  if (log)
2834  log->Printf("Target::%s() called for %s", __FUNCTION__,
2835  launch_info.GetExecutableFile().GetPath().c_str());
2836 
2837  StateType state = eStateInvalid;
2838 
2839  // Scope to temporarily get the process state in case someone has manually
2840  // remotely connected already to a process and we can skip the platform
2841  // launching.
2842  {
2843  ProcessSP process_sp(GetProcessSP());
2844 
2845  if (process_sp) {
2846  state = process_sp->GetState();
2847  if (log)
2848  log->Printf(
2849  "Target::%s the process exists, and its current state is %s",
2850  __FUNCTION__, StateAsCString(state));
2851  } else {
2852  if (log)
2853  log->Printf("Target::%s the process instance doesn't currently exist.",
2854  __FUNCTION__);
2855  }
2856  }
2857 
2858  launch_info.GetFlags().Set(eLaunchFlagDebug);
2859 
2860  // Get the value of synchronous execution here. If you wait till after you
2861  // have started to run, then you could have hit a breakpoint, whose command
2862  // might switch the value, and then you'll pick up that incorrect value.
2863  Debugger &debugger = GetDebugger();
2864  const bool synchronous_execution =
2866 
2867  PlatformSP platform_sp(GetPlatform());
2868 
2869  FinalizeFileActions(launch_info);
2870 
2871  if (state == eStateConnected) {
2872  if (launch_info.GetFlags().Test(eLaunchFlagLaunchInTTY)) {
2873  error.SetErrorString(
2874  "can't launch in tty when launching through a remote connection");
2875  return error;
2876  }
2877  }
2878 
2879  if (!launch_info.GetArchitecture().IsValid())
2880  launch_info.GetArchitecture() = GetArchitecture();
2881 
2882  // If we're not already connected to the process, and if we have a platform
2883  // that can launch a process for debugging, go ahead and do that here.
2884  if (state != eStateConnected && platform_sp &&
2885  platform_sp->CanDebugProcess()) {
2886  if (log)
2887  log->Printf("Target::%s asking the platform to debug the process",
2888  __FUNCTION__);
2889 
2890  // If there was a previous process, delete it before we make the new one.
2891  // One subtle point, we delete the process before we release the reference
2892  // to m_process_sp. That way even if we are the last owner, the process
2893  // will get Finalized before it gets destroyed.
2895 
2896  m_process_sp =
2897  GetPlatform()->DebugProcess(launch_info, debugger, this, error);
2898 
2899  } else {
2900  if (log)
2901  log->Printf("Target::%s the platform doesn't know how to debug a "
2902  "process, getting a process plugin to do this for us.",
2903  __FUNCTION__);
2904 
2905  if (state == eStateConnected) {
2906  assert(m_process_sp);
2907  } else {
2908  // Use a Process plugin to construct the process.
2909  const char *plugin_name = launch_info.GetProcessPluginName();
2910  CreateProcess(launch_info.GetListener(), plugin_name, nullptr);
2911  }
2912 
2913  // Since we didn't have a platform launch the process, launch it here.
2914  if (m_process_sp)
2915  error = m_process_sp->Launch(launch_info);
2916  }
2917 
2918  if (!m_process_sp) {
2919  if (error.Success())
2920  error.SetErrorString("failed to launch or debug process");
2921  return error;
2922  }
2923 
2924  if (error.Success()) {
2925  if (synchronous_execution ||
2926  !launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) {
2927  ListenerSP hijack_listener_sp(launch_info.GetHijackListener());
2928  if (!hijack_listener_sp) {
2929  hijack_listener_sp =
2930  Listener::MakeListener("lldb.Target.Launch.hijack");
2931  launch_info.SetHijackListener(hijack_listener_sp);
2932  m_process_sp->HijackProcessEvents(hijack_listener_sp);
2933  }
2934 
2935  StateType state = m_process_sp->WaitForProcessToStop(
2936  llvm::None, nullptr, false, hijack_listener_sp, nullptr);
2937 
2938  if (state == eStateStopped) {
2939  if (!launch_info.GetFlags().Test(eLaunchFlagStopAtEntry)) {
2940  if (synchronous_execution) {
2941  // Now we have handled the stop-from-attach, and we are just switching
2942  // to a synchronous resume. So we should switch to the SyncResume
2943  // hijacker.
2944  m_process_sp->RestoreProcessEvents();
2945  m_process_sp->ResumeSynchronous(stream);
2946  } else {
2947  m_process_sp->RestoreProcessEvents();
2948  error = m_process_sp->PrivateResume();
2949  }
2950  if (!error.Success()) {
2951  Status error2;
2952  error2.SetErrorStringWithFormat(
2953  "process resume at entry point failed: %s", error.AsCString());
2954  error = error2;
2955  }
2956  }
2957  } else if (state == eStateExited) {
2958  bool with_shell = !!launch_info.GetShell();
2959  const int exit_status = m_process_sp->GetExitStatus();
2960  const char *exit_desc = m_process_sp->GetExitDescription();
2961 #define LAUNCH_SHELL_MESSAGE \
2962  "\n'r' and 'run' are aliases that default to launching through a " \
2963  "shell.\nTry launching without going through a shell by using 'process " \
2964  "launch'."
2965  if (exit_desc && exit_desc[0]) {
2966  if (with_shell)
2968  "process exited with status %i (%s)" LAUNCH_SHELL_MESSAGE,
2969  exit_status, exit_desc);
2970  else
2971  error.SetErrorStringWithFormat("process exited with status %i (%s)",
2972  exit_status, exit_desc);
2973  } else {
2974  if (with_shell)
2976  "process exited with status %i" LAUNCH_SHELL_MESSAGE,
2977  exit_status);
2978  else
2979  error.SetErrorStringWithFormat("process exited with status %i",
2980  exit_status);
2981  }
2982  } else {
2984  "initial process state wasn't stopped: %s", StateAsCString(state));
2985  }
2986  }
2987  m_process_sp->RestoreProcessEvents();
2988  } else {
2989  Status error2;
2990  error2.SetErrorStringWithFormat("process launch failed: %s",
2991  error.AsCString());
2992  error = error2;
2993  }
2994  return error;
2995 }
2996 
2998  auto state = eStateInvalid;
2999  auto process_sp = GetProcessSP();
3000  if (process_sp) {
3001  state = process_sp->GetState();
3002  if (process_sp->IsAlive() && state != eStateConnected) {
3003  if (state == eStateAttaching)
3004  return Status("process attach is in progress");
3005  return Status("a process is already being debugged");
3006  }
3007  }
3008 
3009  const ModuleSP old_exec_module_sp = GetExecutableModule();
3010 
3011  // If no process info was specified, then use the target executable name as
3012  // the process to attach to by default
3013  if (!attach_info.ProcessInfoSpecified()) {
3014  if (old_exec_module_sp)
3015  attach_info.GetExecutableFile().GetFilename() =
3016  old_exec_module_sp->GetPlatformFileSpec().GetFilename();
3017 
3018  if (!attach_info.ProcessInfoSpecified()) {
3019  return Status("no process specified, create a target with a file, or "
3020  "specify the --pid or --name");
3021  }
3022  }
3023 
3024  const auto platform_sp =
3026  ListenerSP hijack_listener_sp;
3027  const bool async = attach_info.GetAsync();
3028  if (!async) {
3029  hijack_listener_sp =
3030  Listener::MakeListener("lldb.Target.Attach.attach.hijack");
3031  attach_info.SetHijackListener(hijack_listener_sp);
3032  }
3033 
3034  Status error;
3035  if (state != eStateConnected && platform_sp != nullptr &&
3036  platform_sp->CanDebugProcess()) {
3037  SetPlatform(platform_sp);
3038  process_sp = platform_sp->Attach(attach_info, GetDebugger(), this, error);
3039  } else {
3040  if (state != eStateConnected) {
3041  const char *plugin_name = attach_info.GetProcessPluginName();
3042  process_sp =
3044  plugin_name, nullptr);
3045  if (process_sp == nullptr) {
3047  "failed to create process using plugin %s",
3048  (plugin_name) ? plugin_name : "null");
3049  return error;
3050  }
3051  }
3052  if (hijack_listener_sp)
3053  process_sp->HijackProcessEvents(hijack_listener_sp);
3054  error = process_sp->Attach(attach_info);
3055  }
3056 
3057  if (error.Success() && process_sp) {
3058  if (async) {
3059  process_sp->RestoreProcessEvents();
3060  } else {
3061  state = process_sp->WaitForProcessToStop(
3062  llvm::None, nullptr, false, attach_info.GetHijackListener(), stream);
3063  process_sp->RestoreProcessEvents();
3064 
3065  if (state != eStateStopped) {
3066  const char *exit_desc = process_sp->GetExitDescription();
3067  if (exit_desc)
3068  error.SetErrorStringWithFormat("%s", exit_desc);
3069  else
3070  error.SetErrorString(
3071  "process did not stop (no such process or permission problem?)");
3072  process_sp->Destroy(false);
3073  }
3074  }
3075  }
3076  return error;
3077 }
3078 
3079 void Target::FinalizeFileActions(ProcessLaunchInfo &info) {
3081 
3082  // Finalize the file actions, and if none were given, default to opening up a
3083  // pseudo terminal
3084  PlatformSP platform_sp = GetPlatform();
3085  const bool default_to_use_pty =
3086  m_platform_sp ? m_platform_sp->IsHost() : false;
3087  LLDB_LOG(
3088  log,
3089  "have platform={0}, platform_sp->IsHost()={1}, default_to_use_pty={2}",
3090  bool(platform_sp),
3091  platform_sp ? (platform_sp->IsHost() ? "true" : "false") : "n/a",
3092  default_to_use_pty);
3093 
3094  // If nothing for stdin or stdout or stderr was specified, then check the
3095  // process for any default settings that were set with "settings set"
3096  if (info.GetFileActionForFD(STDIN_FILENO) == nullptr ||
3097  info.GetFileActionForFD(STDOUT_FILENO) == nullptr ||
3098  info.GetFileActionForFD(STDERR_FILENO) == nullptr) {
3099  LLDB_LOG(log, "at least one of stdin/stdout/stderr was not set, evaluating "
3100  "default handling");
3101 
3102  if (info.GetFlags().Test(eLaunchFlagLaunchInTTY)) {
3103  // Do nothing, if we are launching in a remote terminal no file actions
3104  // should be done at all.
3105  return;
3106  }
3107 
3108  if (info.GetFlags().Test(eLaunchFlagDisableSTDIO)) {
3109  LLDB_LOG(log, "eLaunchFlagDisableSTDIO set, adding suppression action "
3110  "for stdin, stdout and stderr");
3111  info.AppendSuppressFileAction(STDIN_FILENO, true, false);
3112  info.AppendSuppressFileAction(STDOUT_FILENO, false, true);
3113  info.AppendSuppressFileAction(STDERR_FILENO, false, true);
3114  } else {
3115  // Check for any values that might have gotten set with any of: (lldb)
3116  // settings set target.input-path (lldb) settings set target.output-path
3117  // (lldb) settings set target.error-path
3118  FileSpec in_file_spec;
3119  FileSpec out_file_spec;
3120  FileSpec err_file_spec;
3121  // Only override with the target settings if we don't already have an
3122  // action for in, out or error
3123  if (info.GetFileActionForFD(STDIN_FILENO) == nullptr)
3124  in_file_spec = GetStandardInputPath();
3125  if (info.GetFileActionForFD(STDOUT_FILENO) == nullptr)
3126  out_file_spec = GetStandardOutputPath();
3127  if (info.GetFileActionForFD(STDERR_FILENO) == nullptr)
3128  err_file_spec = GetStandardErrorPath();
3129 
3130  LLDB_LOG(log, "target stdin='{0}', target stdout='{1}', stderr='{1}'",
3131  in_file_spec, out_file_spec, err_file_spec);
3132 
3133  if (in_file_spec) {
3134  info.AppendOpenFileAction(STDIN_FILENO, in_file_spec, true, false);
3135  LLDB_LOG(log, "appended stdin open file action for {0}", in_file_spec);
3136  }
3137 
3138  if (out_file_spec) {
3139  info.AppendOpenFileAction(STDOUT_FILENO, out_file_spec, false, true);
3140  LLDB_LOG(log, "appended stdout open file action for {0}",
3141  out_file_spec);
3142  }
3143 
3144  if (err_file_spec) {
3145  info.AppendOpenFileAction(STDERR_FILENO, err_file_spec, false, true);
3146  LLDB_LOG(log, "appended stderr open file action for {0}",
3147  err_file_spec);
3148  }
3149 
3150  if (default_to_use_pty &&
3151  (!in_file_spec || !out_file_spec || !err_file_spec)) {
3152  llvm::Error Err = info.SetUpPtyRedirection();
3153  LLDB_LOG_ERROR(log, std::move(Err), "SetUpPtyRedirection failed: {0}");
3154  }
3155  }
3156  }
3157 }
3158 
3159 // Target::StopHook
3160 Target::StopHook::StopHook(lldb::TargetSP target_sp, lldb::user_id_t uid)
3161  : UserID(uid), m_target_sp(target_sp), m_commands(), m_specifier_sp(),
3162  m_thread_spec_up() {}
3163 
3165  : UserID(rhs.GetID()), m_target_sp(rhs.m_target_sp),
3166  m_commands(rhs.m_commands), m_specifier_sp(rhs.m_specifier_sp),
3167  m_thread_spec_up(), m_active(rhs.m_active),
3168  m_auto_continue(rhs.m_auto_continue) {
3169  if (rhs.m_thread_spec_up)
3170  m_thread_spec_up.reset(new ThreadSpec(*rhs.m_thread_spec_up));
3171 }
3172 
3173 Target::StopHook::~StopHook() = default;
3174 
3176  m_specifier_sp.reset(specifier);
3177 }
3178 
3180  m_thread_spec_up.reset(specifier);
3181 }
3182 
3184  lldb::DescriptionLevel level) const {
3185  int indent_level = s->GetIndentLevel();
3186 
3187  s->SetIndentLevel(indent_level + 2);
3188 
3189  s->Printf("Hook: %" PRIu64 "\n", GetID());
3190  if (m_active)
3191  s->Indent("State: enabled\n");
3192  else
3193  s->Indent("State: disabled\n");
3194 
3195  if (m_auto_continue)
3196  s->Indent("AutoContinue on\n");
3197 
3198  if (m_specifier_sp) {
3199  s->Indent();
3200  s->PutCString("Specifier:\n");
3201  s->SetIndentLevel(indent_level + 4);
3202  m_specifier_sp->GetDescription(s, level);
3203  s->SetIndentLevel(indent_level + 2);
3204  }
3205 
3206  if (m_thread_spec_up) {
3207  StreamString tmp;
3208  s->Indent("Thread:\n");
3209  m_thread_spec_up->GetDescription(&tmp, level);
3210  s->SetIndentLevel(indent_level + 4);
3211  s->Indent(tmp.GetString());
3212  s->PutCString("\n");
3213  s->SetIndentLevel(indent_level + 2);
3214  }
3215 
3216  s->Indent("Commands: \n");
3217  s->SetIndentLevel(indent_level + 4);
3218  uint32_t num_commands = m_commands.GetSize();
3219  for (uint32_t i = 0; i < num_commands; i++) {
3220  s->Indent(m_commands.GetStringAtIndex(i));
3221  s->PutCString("\n");
3222  }
3223  s->SetIndentLevel(indent_level);
3224 }
3225 
3226 // class TargetProperties
3227 
3228 // clang-format off
3229 static constexpr OptionEnumValueElement g_dynamic_value_types[] = {
3230  {eNoDynamicValues, "no-dynamic-values",
3231  "Don't calculate the dynamic type of values"},
3232  {eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values "
3233  "even if you have to run the target."},
3234  {eDynamicDontRunTarget, "no-run-target",
3235  "Calculate the dynamic type of values, but don't run the target."} };
3236 
3238  return OptionEnumValues(g_dynamic_value_types);
3239 }
3240 
3241 static constexpr OptionEnumValueElement g_inline_breakpoint_enums[] = {
3242  {eInlineBreakpointsNever, "never", "Never look for inline breakpoint "
3243  "locations (fastest). This setting "
3244  "should only be used if you know that "
3245  "no inlining occurs in your programs."},
3246  {eInlineBreakpointsHeaders, "headers",
3247  "Only check for inline breakpoint locations when setting breakpoints in "
3248  "header files, but not when setting breakpoint in implementation source "
3249  "files (default)."},
3250  {eInlineBreakpointsAlways, "always",
3251  "Always look for inline breakpoint locations when setting file and line "
3252  "breakpoints (slower but most accurate)."} };
3253 
3254 typedef enum x86DisassemblyFlavor {
3259 
3260 static constexpr OptionEnumValueElement g_x86_dis_flavor_value_types[] = {
3261  {eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
3262  {eX86DisFlavorIntel, "intel", "Intel disassembler flavor."},
3263  {eX86DisFlavorATT, "att", "AT&T disassembler flavor."} };
3264 
3265 static constexpr OptionEnumValueElement g_hex_immediate_style_values[] = {
3266  {Disassembler::eHexStyleC, "c", "C-style (0xffff)."},
3267  {Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."} };
3268 
3269 static constexpr OptionEnumValueElement g_load_script_from_sym_file_values[] = {
3270  {eLoadScriptFromSymFileTrue, "true",
3271  "Load debug scripts inside symbol files"},
3272  {eLoadScriptFromSymFileFalse, "false",
3273  "Do not load debug scripts inside symbol files."},
3274  {eLoadScriptFromSymFileWarn, "warn",
3275  "Warn about debug scripts inside symbol files but do not load them."} };
3276 
3277 static constexpr
3279  {eLoadCWDlldbinitTrue, "true",
3280  "Load .lldbinit files from current directory"},
3281  {eLoadCWDlldbinitFalse, "false",
3282  "Do not load .lldbinit files from current directory"},
3283  {eLoadCWDlldbinitWarn, "warn",
3284  "Warn about loading .lldbinit files from current directory"} };
3285 
3286 static constexpr OptionEnumValueElement g_memory_module_load_level_values[] = {
3287  {eMemoryModuleLoadLevelMinimal, "minimal",
3288  "Load minimal information when loading modules from memory. Currently "
3289  "this setting loads sections only."},
3290  {eMemoryModuleLoadLevelPartial, "partial",
3291  "Load partial information when loading modules from memory. Currently "
3292  "this setting loads sections and function bounds."},
3293  {eMemoryModuleLoadLevelComplete, "complete",
3294  "Load complete information when loading modules from memory. Currently "
3295  "this setting loads sections and all symbols."} };
3296 
3297 static constexpr PropertyDefinition g_properties[] = {
3298  {"default-arch", OptionValue::eTypeArch, true, 0, nullptr, {},
3299  "Default architecture to choose, when there's a choice."},
3300  {"move-to-nearest-code", OptionValue::eTypeBoolean, false, true, nullptr,
3301  {}, "Move breakpoints to nearest code."},
3302  {"language", OptionValue::eTypeLanguage, false, eLanguageTypeUnknown,
3303  nullptr, {},
3304  "The language to use when interpreting expressions entered in commands."},
3305  {"expr-prefix", OptionValue::eTypeFileSpec, false, 0, nullptr, {},
3306  "Path to a file containing expressions to be prepended to all "
3307  "expressions."},
3308  {"prefer-dynamic-value", OptionValue::eTypeEnum, false,
3309  eDynamicDontRunTarget, nullptr, OptionEnumValues(g_dynamic_value_types),
3310  "Should printed values be shown as their dynamic value."},
3311  {"enable-synthetic-value", OptionValue::eTypeBoolean, false, true, nullptr,
3312  {}, "Should synthetic values be used by default whenever available."},
3313  {"skip-prologue", OptionValue::eTypeBoolean, false, true, nullptr, {},
3314  "Skip function prologues when setting breakpoints by name."},
3315  {"source-map", OptionValue::eTypePathMap, false, 0, nullptr, {},
3316  "Source path remappings are used to track the change of location between "
3317  "a source file when built, and "
3318  "where it exists on the current system. It consists of an array of "
3319  "duples, the first element of each duple is "
3320  "some part (starting at the root) of the path to the file when it was "
3321  "built, "
3322  "and the second is where the remainder of the original build hierarchy is "
3323  "rooted on the local system. "
3324  "Each element of the array is checked in order and the first one that "
3325  "results in a match wins."},
3326  {"exec-search-paths", OptionValue::eTypeFileSpecList, false, 0, nullptr,
3327  {}, "Executable search paths to use when locating executable files "
3328  "whose paths don't match the local file system."},
3329  {"debug-file-search-paths", OptionValue::eTypeFileSpecList, false, 0,
3330  nullptr, {},
3331  "List of directories to be searched when locating debug symbol files. "
3332  "See also symbols.enable-external-lookup."},
3333  {"clang-module-search-paths", OptionValue::eTypeFileSpecList, false, 0,
3334  nullptr, {},
3335  "List of directories to be searched when locating modules for Clang."},
3336  {"auto-import-clang-modules", OptionValue::eTypeBoolean, false, true,
3337  nullptr, {},
3338  "Automatically load Clang modules referred to by the program."},
3339  {"import-std-module", OptionValue::eTypeBoolean, false, false,
3340  nullptr, {},
3341  "Import the C++ std module to improve debugging STL containers."},
3342  {"auto-apply-fixits", OptionValue::eTypeBoolean, false, true, nullptr,
3343  {}, "Automatically apply fix-it hints to expressions."},
3344  {"notify-about-fixits", OptionValue::eTypeBoolean, false, true, nullptr,
3345  {}, "Print the fixed expression text."},
3346  {"save-jit-objects", OptionValue::eTypeBoolean, false, false, nullptr,
3347  {}, "Save intermediate object files generated by the LLVM JIT"},
3348  {"max-children-count", OptionValue::eTypeSInt64, false, 256, nullptr,
3349  {}, "Maximum number of children to expand in any level of depth."},
3350  {"max-string-summary-length", OptionValue::eTypeSInt64, false, 1024,
3351  nullptr, {},
3352  "Maximum number of characters to show when using %s in summary strings."},
3353  {"max-memory-read-size", OptionValue::eTypeSInt64, false, 1024, nullptr,
3354  {}, "Maximum number of bytes that 'memory read' will fetch before "
3355  "--force must be specified."},
3356  {"breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean, false,
3357  true, nullptr, {}, "Consult the platform module avoid list when "
3358  "setting non-module specific breakpoints."},
3359  {"arg0", OptionValue::eTypeString, false, 0, nullptr, {},
3360  "The first argument passed to the program in the argument array which can "
3361  "be different from the executable itself."},
3362  {"run-args", OptionValue::eTypeArgs, false, 0, nullptr, {},
3363  "A list containing all the arguments to be passed to the executable when "
3364  "it is run. Note that this does NOT include the argv[0] which is in "
3365  "target.arg0."},
3367  nullptr, {}, "A list of all the environment variables to be passed "
3368  "to the executable's environment, and their values."},
3369  {"inherit-env", OptionValue::eTypeBoolean, false, true, nullptr, {},
3370  "Inherit the environment from the process that is running LLDB."},
3371  {"input-path", OptionValue::eTypeFileSpec, false, 0, nullptr, {},
3372  "The file/path to be used by the executable program for reading its "
3373  "standard input."},
3374  {"output-path", OptionValue::eTypeFileSpec, false, 0, nullptr, {},
3375  "The file/path to be used by the executable program for writing its "
3376  "standard output."},
3377  {"error-path", OptionValue::eTypeFileSpec, false, 0, nullptr, {},
3378  "The file/path to be used by the executable program for writing its "
3379  "standard error."},
3380  {"detach-on-error", OptionValue::eTypeBoolean, false, true, nullptr,
3381  {}, "debugserver will detach (rather than killing) a process if it "
3382  "loses connection with lldb."},
3383  {"preload-symbols", OptionValue::eTypeBoolean, false, true, nullptr, {},
3384  "Enable loading of symbol tables before they are needed."},
3385  {"disable-aslr", OptionValue::eTypeBoolean, false, true, nullptr, {},
3386  "Disable Address Space Layout Randomization (ASLR)"},
3387  {"disable-stdio", OptionValue::eTypeBoolean, false, false, nullptr, {},
3388  "Disable stdin/stdout for process (e.g. for a GUI application)"},
3389  {"inline-breakpoint-strategy", OptionValue::eTypeEnum, false,
3390  eInlineBreakpointsAlways, nullptr,
3391  OptionEnumValues(g_inline_breakpoint_enums),
3392  "The strategy to use when settings breakpoints by file and line. "
3393  "Breakpoint locations can end up being inlined by the compiler, so that a "
3394  "compile unit 'a.c' might contain an inlined function from another source "
3395  "file. "
3396  "Usually this is limited to breakpoint locations from inlined functions "
3397  "from header or other include files, or more accurately "
3398  "non-implementation source files. "
3399  "Sometimes code might #include implementation files and cause inlined "
3400  "breakpoint locations in inlined implementation files. "
3401  "Always checking for inlined breakpoint locations can be expensive "
3402  "(memory and time), so if you have a project with many headers "
3403  "and find that setting breakpoints is slow, then you can change this "
3404  "setting to headers. "
3405  "This setting allows you to control exactly which strategy is used when "
3406  "setting "
3407  "file and line breakpoints."},
3408  // FIXME: This is the wrong way to do per-architecture settings, but we
3409  // don't have a general per architecture settings system in place yet.
3410  {"x86-disassembly-flavor", OptionValue::eTypeEnum, false,
3411  eX86DisFlavorDefault, nullptr,
3412  OptionEnumValues(g_x86_dis_flavor_value_types),
3413  "The default disassembly flavor to use for x86 or x86-64 targets."},
3414  {"use-hex-immediates", OptionValue::eTypeBoolean, false, true, nullptr,
3415  {}, "Show immediates in disassembly as hexadecimal."},
3416  {"hex-immediate-style", OptionValue::eTypeEnum, false,
3417  Disassembler::eHexStyleC, nullptr,
3418  OptionEnumValues(g_hex_immediate_style_values),
3419  "Which style to use for printing hexadecimal disassembly values."},
3420  {"use-fast-stepping", OptionValue::eTypeBoolean, false, true, nullptr,
3421  {}, "Use a fast stepping algorithm based on running from branch to "
3422  "branch rather than instruction single-stepping."},
3423  {"load-script-from-symbol-file", OptionValue::eTypeEnum, false,
3424  eLoadScriptFromSymFileWarn, nullptr,
3425  OptionEnumValues(g_load_script_from_sym_file_values),
3426  "Allow LLDB to load scripting resources embedded in symbol files when "
3427  "available."},
3428  {"load-cwd-lldbinit", OptionValue::eTypeEnum, false, eLoadCWDlldbinitWarn,
3429  nullptr, OptionEnumValues(g_load_current_working_dir_lldbinit_values),
3430  "Allow LLDB to .lldbinit files from the current directory automatically."},
3431  {"memory-module-load-level", OptionValue::eTypeEnum, false,
3433  OptionEnumValues(g_memory_module_load_level_values),
3434  "Loading modules from memory can be slow as reading the symbol tables and "
3435  "other data can take a long time depending on your connection to the "
3436  "debug target. "
3437  "This setting helps users control how much information gets loaded when "
3438  "loading modules from memory."
3439  "'complete' is the default value for this setting which will load all "
3440  "sections and symbols by reading them from memory (slowest, most "
3441  "accurate). "
3442  "'partial' will load sections and attempt to find function bounds without "
3443  "downloading the symbol table (faster, still accurate, missing symbol "
3444  "names). "
3445  "'minimal' is the fastest setting and will load section data with no "
3446  "symbols, but should rarely be used as stack frames in these memory "
3447  "regions will be inaccurate and not provide any context (fastest). "},
3448  {"display-expression-in-crashlogs", OptionValue::eTypeBoolean, false, false,
3449  nullptr, {}, "Expressions that crash will show up in crash logs if "
3450  "the host system supports executable specific crash log "
3451  "strings and this setting is set to true."},
3452  {"trap-handler-names", OptionValue::eTypeArray, true,
3453  OptionValue::eTypeString, nullptr, {},
3454  "A list of trap handler function names, e.g. a common Unix user process "
3455  "one is _sigtramp."},
3456  {"display-runtime-support-values", OptionValue::eTypeBoolean, false, false,
3457  nullptr, {}, "If true, LLDB will show variables that are meant to "
3458  "support the operation of a language's runtime support."},
3459  {"display-recognized-arguments", OptionValue::eTypeBoolean, false, false,
3460  nullptr, {}, "Show recognized arguments in variable listings by default."},
3461  {"non-stop-mode", OptionValue::eTypeBoolean, false, 0, nullptr, {},
3462  "Disable lock-step debugging, instead control threads independently."},
3463  {"require-hardware-breakpoint", OptionValue::eTypeBoolean, false, 0,
3464  nullptr, {}, "Require all breakpoints to be hardware breakpoints."}};
3465 // clang-format on
3466 
3467 enum {
3514 };
3515 
3517 public:
3519  : OptionValueProperties(name), m_target(nullptr), m_got_host_env(false) {}
3520 
3521  // This constructor is used when creating TargetOptionValueProperties when it
3522  // is part of a new lldb_private::Target instance. It will copy all current
3523  // global property values as needed
3525  const TargetPropertiesSP &target_properties_sp)
3526  : OptionValueProperties(*target_properties_sp->GetValueProperties()),
3527  m_target(target), m_got_host_env(false) {}
3528 
3530  bool will_modify,
3531  uint32_t idx) const override {
3532  // When getting the value for a key from the target options, we will always
3533  // try and grab the setting from the current target if there is one. Else
3534  // we just use the one from this instance.
3535  if (idx == ePropertyEnvVars)
3536  GetHostEnvironmentIfNeeded();
3537 
3538  if (exe_ctx) {
3539  Target *target = exe_ctx->GetTargetPtr();
3540  if (target) {
3541  TargetOptionValueProperties *target_properties =
3542  static_cast<TargetOptionValueProperties *>(
3543  target->GetValueProperties().get());
3544  if (this != target_properties)
3545  return target_properties->ProtectedGetPropertyAtIndex(idx);
3546  }
3547  }
3548  return ProtectedGetPropertyAtIndex(idx);
3549  }
3550 
3551  lldb::TargetSP GetTargetSP() { return m_target->shared_from_this(); }
3552 
3553 protected:
3555  if (!m_got_host_env) {
3556  if (m_target) {
3557  m_got_host_env = true;
3558  const uint32_t idx = ePropertyInheritEnv;
3559  if (GetPropertyAtIndexAsBoolean(
3560  nullptr, idx, g_properties[idx].default_uint_value != 0)) {
3561  PlatformSP platform_sp(m_target->GetPlatform());
3562  if (platform_sp) {
3563  Environment env = platform_sp->GetEnvironment();
3564  OptionValueDictionary *env_dict =
3565  GetPropertyAtIndexAsOptionValueDictionary(nullptr,
3567  if (env_dict) {
3568  const bool can_replace = false;
3569  for (const auto &KV : env) {
3570  // Don't allow existing keys to be replaced with ones we get
3571  // from the platform environment
3572  env_dict->SetValueForKey(
3573  ConstString(KV.first()),
3574  OptionValueSP(new OptionValueString(KV.second.c_str())),
3575  can_replace);
3576  }
3577  }
3578  }
3579  }
3580  }
3581  }
3582  }
3584  mutable bool m_got_host_env;
3585 };
3586 
3587 // TargetProperties
3589  {"inject-local-vars", OptionValue::eTypeBoolean, true, true, nullptr,
3590  {},
3591  "If true, inject local variables explicitly into the expression text. "
3592  "This will fix symbol resolution when there are name collisions between "
3593  "ivars and local variables. "
3594  "But it can make expressions run much more slowly."},
3595  {"use-modern-type-lookup", OptionValue::eTypeBoolean, true, false, nullptr,
3596  {}, "If true, use Clang's modern type lookup infrastructure."}};
3597 
3599 
3601 public:
3605 };
3606 
3608  : Properties(OptionValuePropertiesSP(
3611 }
3612 
3613 // TargetProperties
3615  : Properties(), m_launch_info() {
3616  if (target) {
3617  m_collection_sp = std::make_shared<TargetOptionValueProperties>(
3618  target, Target::GetGlobalProperties());
3619 
3620  // Set callbacks to update launch_info whenever "settins set" updated any
3621  // of these properties
3622  m_collection_sp->SetValueChangedCallback(
3623  ePropertyArg0, TargetProperties::Arg0ValueChangedCallback, this);
3624  m_collection_sp->SetValueChangedCallback(
3625  ePropertyRunArgs, TargetProperties::RunArgsValueChangedCallback, this);
3626  m_collection_sp->SetValueChangedCallback(
3627  ePropertyEnvVars, TargetProperties::EnvVarsValueChangedCallback, this);
3628  m_collection_sp->SetValueChangedCallback(
3629  ePropertyInputPath, TargetProperties::InputPathValueChangedCallback,
3630  this);
3631  m_collection_sp->SetValueChangedCallback(
3632  ePropertyOutputPath, TargetProperties::OutputPathValueChangedCallback,
3633  this);
3634  m_collection_sp->SetValueChangedCallback(
3635  ePropertyErrorPath, TargetProperties::ErrorPathValueChangedCallback,
3636  this);
3637  m_collection_sp->SetValueChangedCallback(
3639  TargetProperties::DetachOnErrorValueChangedCallback, this);
3640  m_collection_sp->SetValueChangedCallback(
3641  ePropertyDisableASLR, TargetProperties::DisableASLRValueChangedCallback,
3642  this);
3643  m_collection_sp->SetValueChangedCallback(
3645  TargetProperties::DisableSTDIOValueChangedCallback, this);
3646 
3647  m_experimental_properties_up.reset(new TargetExperimentalProperties());
3648  m_collection_sp->AppendProperty(
3650  ConstString("Experimental settings - setting these won't produce "
3651  "errors if the setting is not present."),
3652  true, m_experimental_properties_up->GetValueProperties());
3653 
3654  // Update m_launch_info once it was created
3655  Arg0ValueChangedCallback(this, nullptr);
3656  RunArgsValueChangedCallback(this, nullptr);
3657  // EnvVarsValueChangedCallback(this, nullptr); // FIXME: cause segfault in
3658  // Target::GetPlatform()
3659  InputPathValueChangedCallback(this, nullptr);
3660  OutputPathValueChangedCallback(this, nullptr);
3661  ErrorPathValueChangedCallback(this, nullptr);
3662  DetachOnErrorValueChangedCallback(this, nullptr);
3663  DisableASLRValueChangedCallback(this, nullptr);
3664  DisableSTDIOValueChangedCallback(this, nullptr);
3665  } else {
3666  m_collection_sp =
3667  std::make_shared<TargetOptionValueProperties>(ConstString("target"));
3668  m_collection_sp->Initialize(g_properties);
3669  m_experimental_properties_up.reset(new TargetExperimentalProperties());
3670  m_collection_sp->AppendProperty(
3672  ConstString("Experimental settings - setting these won't produce "
3673  "errors if the setting is not present."),
3674  true, m_experimental_properties_up->GetValueProperties());
3675  m_collection_sp->AppendProperty(
3676  ConstString("process"), ConstString("Settings specific to processes."),
3678  }
3679 }
3680 
3682 
3684  ExecutionContext *exe_ctx) const {
3685  const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
3686  exe_ctx, false, ePropertyExperimental);
3687  OptionValueProperties *exp_values =
3688  exp_property->GetValue()->GetAsProperties();
3689  if (exp_values)
3690  return exp_values->GetPropertyAtIndexAsBoolean(
3691  exe_ctx, ePropertyInjectLocalVars, true);
3692  else
3693  return true;
3694 }
3695 
3697  bool b) {
3698  const Property *exp_property =
3699  m_collection_sp->GetPropertyAtIndex(exe_ctx, true, ePropertyExperimental);
3700  OptionValueProperties *exp_values =
3701  exp_property->GetValue()->GetAsProperties();
3702  if (exp_values)
3704  true);
3705 }
3706 
3708  const Property *exp_property = m_collection_sp->GetPropertyAtIndex(
3709  nullptr, false, ePropertyExperimental);
3710  OptionValueProperties *exp_values =
3711  exp_property->GetValue()->GetAsProperties();
3712  if (exp_values)
3713  return exp_values->GetPropertyAtIndexAsBoolean(
3714  nullptr, ePropertyUseModernTypeLookup, true);
3715  else
3716  return true;
3717 }
3718 
3720  OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
3721  nullptr, ePropertyDefaultArch);
3722  if (value)
3723  return value->GetCurrentValue();
3724  return ArchSpec();
3725 }
3726 
3728  OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch(
3729  nullptr, ePropertyDefaultArch);
3730  if (value)
3731  return value->SetCurrentValue(arch, true);
3732 }
3733 
3736  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3737  nullptr, idx, g_properties[idx].default_uint_value != 0);
3738 }
3739 
3741  const uint32_t idx = ePropertyPreferDynamic;
3742  return (lldb::DynamicValueType)
3743  m_collection_sp->GetPropertyAtIndexAsEnumeration(
3744  nullptr, idx, g_properties[idx].default_uint_value);
3745 }
3746 
3748  const uint32_t idx = ePropertyPreferDynamic;
3749  return m_collection_sp->SetPropertyAtIndexAsEnumeration(nullptr, idx, d);
3750 }
3751 
3753  const uint32_t idx = ePropertyPreloadSymbols;
3754  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3755  nullptr, idx, g_properties[idx].default_uint_value != 0);
3756 }
3757 
3759  const uint32_t idx = ePropertyPreloadSymbols;
3760  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3761 }
3762 
3764  const uint32_t idx = ePropertyDisableASLR;
3765  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3766  nullptr, idx, g_properties[idx].default_uint_value != 0);
3767 }
3768 
3770  const uint32_t idx = ePropertyDisableASLR;
3771  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3772 }
3773 
3775  const uint32_t idx = ePropertyDetachOnError;
3776  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3777  nullptr, idx, g_properties[idx].default_uint_value != 0);
3778 }
3779 
3781  const uint32_t idx = ePropertyDetachOnError;
3782  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3783 }
3784 
3786  const uint32_t idx = ePropertyDisableSTDIO;
3787  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3788  nullptr, idx, g_properties[idx].default_uint_value != 0);
3789 }
3790 
3792  const uint32_t idx = ePropertyDisableSTDIO;
3793  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
3794 }
3795 
3798  const char *return_value;
3799 
3800  x86DisassemblyFlavor flavor_value =
3801  (x86DisassemblyFlavor)m_collection_sp->GetPropertyAtIndexAsEnumeration(
3802  nullptr, idx, g_properties[idx].default_uint_value);
3803  return_value = g_x86_dis_flavor_value_types[flavor_value].string_value;
3804  return return_value;
3805 }
3806 
3808  const uint32_t idx = ePropertyInlineStrategy;
3809  return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration(
3810  nullptr, idx, g_properties[idx].default_uint_value);
3811 }
3812 
3813 llvm::StringRef TargetProperties::GetArg0() const {
3814  const uint32_t idx = ePropertyArg0;
3815  return m_collection_sp->GetPropertyAtIndexAsString(nullptr, idx, llvm::StringRef());
3816 }
3817 
3818 void TargetProperties::SetArg0(llvm::StringRef arg) {
3819  const uint32_t idx = ePropertyArg0;
3820  m_collection_sp->SetPropertyAtIndexAsString(
3821  nullptr, idx, arg);
3822  m_launch_info.SetArg0(arg);
3823 }
3824 
3826  const uint32_t idx = ePropertyRunArgs;
3827  return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
3828 }
3829 
3831  const uint32_t idx = ePropertyRunArgs;
3832  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
3833  m_launch_info.GetArguments() = args;
3834 }
3835 
3837  // TODO: Get rid of the Args intermediate step
3838  Args env;
3839  const uint32_t idx = ePropertyEnvVars;
3840  m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, env);
3841  return Environment(env);
3842 }
3843 
3845  // TODO: Get rid of the Args intermediate step
3846  const uint32_t idx = ePropertyEnvVars;
3847  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, Args(env));
3848  m_launch_info.GetEnvironment() = std::move(env);
3849 }
3850 
3852  const uint32_t idx = ePropertySkipPrologue;
3853  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3854  nullptr, idx, g_properties[idx].default_uint_value != 0);
3855 }
3856 
3858  const uint32_t idx = ePropertySourceMap;
3859  OptionValuePathMappings *option_value =
3860  m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings(nullptr,
3861  false, idx);
3862  assert(option_value);
3863  return option_value->GetCurrentValue();
3864 }
3865 
3868  OptionValueFileSpecList *option_value =
3869  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
3870  false, idx);
3871  assert(option_value);
3872  option_value->AppendCurrentValue(dir);
3873 }
3874 
3877  const OptionValueFileSpecList *option_value =
3878  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
3879  false, idx);
3880  assert(option_value);
3881  return option_value->GetCurrentValue();
3882 }
3883 
3886  const OptionValueFileSpecList *option_value =
3887  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
3888  false, idx);
3889  assert(option_value);
3890  return option_value->GetCurrentValue();
3891 }
3892 
3895  const OptionValueFileSpecList *option_value =
3896  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList(nullptr,
3897  false, idx);
3898  assert(option_value);
3899  return option_value->GetCurrentValue();
3900 }
3901 
3904  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3905  nullptr, idx, g_properties[idx].default_uint_value != 0);
3906 }
3907 
3909  const uint32_t idx = ePropertyImportStdModule;
3910  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3911  nullptr, idx, g_properties[idx].default_uint_value != 0);
3912 }
3913 
3915  const uint32_t idx = ePropertyAutoApplyFixIts;
3916  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3917  nullptr, idx, g_properties[idx].default_uint_value != 0);
3918 }
3919 
3922  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3923  nullptr, idx, g_properties[idx].default_uint_value != 0);
3924 }
3925 
3927  const uint32_t idx = ePropertySaveObjects;
3928  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3929  nullptr, idx, g_properties[idx].default_uint_value != 0);
3930 }
3931 
3933  const uint32_t idx = ePropertyEnableSynthetic;
3934  return m_collection_sp->GetPropertyAtIndexAsBoolean(
3935  nullptr, idx, g_properties[idx].default_uint_value != 0);
3936 }
3937 
3939  const uint32_t idx = ePropertyMaxChildrenCount;
3940  return m_collection_sp->GetPropertyAtIndexAsSInt64(
3941  nullptr, idx, g_properties[idx].default_uint_value);
3942 }
3943 
3945  const uint32_t idx = ePropertyMaxSummaryLength;
3946  return m_collection_sp->GetPropertyAtIndexAsSInt64(
3947  nullptr, idx, g_properties[idx].default_uint_value);
3948 }
3949 
3951  const uint32_t idx = ePropertyMaxMemReadSize;
3952  return m_collection_sp->GetPropertyAtIndexAsSInt64(
3953  nullptr, idx, g_properties[idx].default_uint_value);
3954 }
3955 
3957  const uint32_t idx = ePropertyInputPath;
3958  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3959 }
3960 
3961 void TargetProperties::SetStandardInputPath(llvm::StringRef path) {
3962  const uint32_t idx = ePropertyInputPath;
3963  m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
3964 }
3965 
3967  const uint32_t idx = ePropertyOutputPath;
3968  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3969 }
3970 
3971 void TargetProperties::SetStandardOutputPath(llvm::StringRef path) {
3972  const uint32_t idx = ePropertyOutputPath;
3973  m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
3974 }
3975 
3977  const uint32_t idx = ePropertyErrorPath;
3978  return m_collection_sp->GetPropertyAtIndexAsFileSpec(nullptr, idx);
3979 }
3980 
3981 void TargetProperties::SetStandardErrorPath(llvm::StringRef path) {
3982  const uint32_t idx = ePropertyErrorPath;
3983  m_collection_sp->SetPropertyAtIndexAsString(nullptr, idx, path);
3984 }
3985 
3987  OptionValueLanguage *value =
3988  m_collection_sp->GetPropertyAtIndexAsOptionValueLanguage(
3989  nullptr, ePropertyLanguage);
3990  if (value)
3991  return value->GetCurrentValue();
3992  return LanguageType();
3993 }
3994 
3996  const uint32_t idx = ePropertyExprPrefix;
3997  OptionValueFileSpec *file =
3998  m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec(nullptr, false,
3999  idx);
4000  if (file) {
4001  DataBufferSP data_sp(file->GetFileContents());
4002  if (data_sp)
4003  return llvm::StringRef(
4004  reinterpret_cast<const char *>(data_sp->GetBytes()),
4005  data_sp->GetByteSize());
4006  }
4007  return "";
4008 }
4009 
4012  return m_collection_sp->GetPropertyAtIndexAsBoolean(
4013  nullptr, idx, g_properties[idx].default_uint_value != 0);
4014 }
4015 
4017  const uint32_t idx = ePropertyUseHexImmediates;
4018  return m_collection_sp->GetPropertyAtIndexAsBoolean(
4019  nullptr, idx, g_properties[idx].default_uint_value != 0);
4020 }
4021 
4023  const uint32_t idx = ePropertyUseFastStepping;
4024  return m_collection_sp->GetPropertyAtIndexAsBoolean(
4025  nullptr, idx, g_properties[idx].default_uint_value != 0);
4026 }
4027 
4030  return m_collection_sp->GetPropertyAtIndexAsBoolean(
4031  nullptr, idx, g_properties[idx].default_uint_value != 0);
4032 }
4033 
4036  return (LoadScriptFromSymFile)
4037  m_collection_sp->GetPropertyAtIndexAsEnumeration(
4038  nullptr, idx, g_properties[idx].default_uint_value);
4039 }
4040 
4043  return (LoadCWDlldbinitFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(
4044  nullptr, idx, g_properties[idx].default_uint_value);
4045 }
4046 
4050  m_collection_sp->GetPropertyAtIndexAsEnumeration(
4051  nullptr, idx, g_properties[idx].default_uint_value);
4052 }
4053 
4056  return (MemoryModuleLoadLevel)
4057  m_collection_sp->GetPropertyAtIndexAsEnumeration(
4058  nullptr, idx, g_properties[idx].default_uint_value);
4059 }
4060 
4062  const uint32_t idx = ePropertyTrapHandlerNames;
4063  return m_collection_sp->GetPropertyAtIndexAsArgs(nullptr, idx, args);
4064 }
4065 
4067  const uint32_t idx = ePropertyTrapHandlerNames;
4068  m_collection_sp->SetPropertyAtIndexFromArgs(nullptr, idx, args);
4069 }
4070 
4073  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
4074 }
4075 
4078  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4079 }
4080 
4083  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
4084 }
4085 
4088  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4089 }
4090 
4093  return m_collection_sp->GetPropertyAtIndexAsBoolean(nullptr, idx, false);
4094 }
4095 
4098  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4099 }
4100 
4102  m_launch_info.SetArg0(GetArg0()); // FIXME: Arg0 callback doesn't work
4103  return m_launch_info;
4104 }
4105 
4107  const ProcessLaunchInfo &launch_info) {
4108  m_launch_info = launch_info;
4109  SetArg0(launch_info.GetArg0());
4110  SetRunArguments(launch_info.GetArguments());
4111  SetEnvironment(launch_info.GetEnvironment());
4112  const FileAction *input_file_action =
4113  launch_info.GetFileActionForFD(STDIN_FILENO);
4114  if (input_file_action) {
4115  SetStandardInputPath(input_file_action->GetPath());
4116  }
4117  const FileAction *output_file_action =
4118  launch_info.GetFileActionForFD(STDOUT_FILENO);
4119  if (output_file_action) {
4120  SetStandardOutputPath(output_file_action->GetPath());
4121  }
4122  const FileAction *error_file_action =
4123  launch_info.GetFileActionForFD(STDERR_FILENO);
4124  if (error_file_action) {
4125  SetStandardErrorPath(error_file_action->GetPath());
4126  }
4127  SetDetachOnError(launch_info.GetFlags().Test(lldb::eLaunchFlagDetachOnError));
4128  SetDisableASLR(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableASLR));
4129  SetDisableSTDIO(launch_info.GetFlags().Test(lldb::eLaunchFlagDisableSTDIO));
4130 }
4131 
4134  return m_collection_sp->GetPropertyAtIndexAsBoolean(
4135  nullptr, idx, g_properties[idx].default_uint_value != 0);
4136 }
4137 
4140  m_collection_sp->SetPropertyAtIndexAsBoolean(nullptr, idx, b);
4141 }
4142 
4143 void TargetProperties::Arg0ValueChangedCallback(void *target_property_ptr,
4144  OptionValue *) {
4145  TargetProperties *this_ =
4146  reinterpret_cast<TargetProperties *>(target_property_ptr);
4147  this_->m_launch_info.SetArg0(this_->GetArg0());
4148 }
4149 
4150 void TargetProperties::RunArgsValueChangedCallback(void *target_property_ptr,
4151  OptionValue *) {
4152  TargetProperties *this_ =
4153  reinterpret_cast<TargetProperties *>(target_property_ptr);
4154  Args args;
4155  if (this_->GetRunArguments(args))
4156  this_->m_launch_info.GetArguments() = args;
4157 }
4158 
4159 void TargetProperties::EnvVarsValueChangedCallback(void *target_property_ptr,
4160  OptionValue *) {
4161  TargetProperties *this_ =
4162  reinterpret_cast<TargetProperties *>(target_property_ptr);
4163  this_->m_launch_info.GetEnvironment() = this_->GetEnvironment();
4164 }
4165 
4166 void TargetProperties::InputPathValueChangedCallback(void *target_property_ptr,
4167  OptionValue *) {
4168  TargetProperties *this_ =
4169  reinterpret_cast<TargetProperties *>(target_property_ptr);
4170  this_->m_launch_info.AppendOpenFileAction(
4171  STDIN_FILENO, this_->GetStandardInputPath(), true, false);
4172 }
4173 
4174 void TargetProperties::OutputPathValueChangedCallback(void *target_property_ptr,
4175  OptionValue *) {
4176  TargetProperties *this_ =
4177  reinterpret_cast<TargetProperties *>(target_property_ptr);
4178  this_->m_launch_info.AppendOpenFileAction(
4179  STDOUT_FILENO, this_->GetStandardOutputPath(), false, true);
4180 }
4181 
4182 void TargetProperties::ErrorPathValueChangedCallback(void *target_property_ptr,
4183  OptionValue *) {
4184  TargetProperties *this_ =
4185  reinterpret_cast<TargetProperties *>(target_property_ptr);
4186  this_->m_launch_info.AppendOpenFileAction(
4187  STDERR_FILENO, this_->GetStandardErrorPath(), false, true);
4188 }
4189 
4190 void TargetProperties::DetachOnErrorValueChangedCallback(
4191  void *target_property_ptr, OptionValue *) {
4192  TargetProperties *this_ =
4193  reinterpret_cast<TargetProperties *>(target_property_ptr);
4194  if (this_->GetDetachOnError())
4195  this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDetachOnError);
4196  else
4197  this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDetachOnError);
4198 }
4199 
4200 void TargetProperties::DisableASLRValueChangedCallback(
4201  void *target_property_ptr, OptionValue *) {
4202  TargetProperties *this_ =
4203  reinterpret_cast<TargetProperties *>(target_property_ptr);
4204  if (this_->GetDisableASLR())
4205  this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableASLR);
4206  else
4207  this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableASLR);
4208 }
4209 
4210 void TargetProperties::DisableSTDIOValueChangedCallback(
4211  void *target_property_ptr, OptionValue *) {
4212  TargetProperties *this_ =
4213  reinterpret_cast<TargetProperties *>(target_property_ptr);
4214  if (this_->GetDisableSTDIO())
4215  this_->m_launch_info.GetFlags().Set(lldb::eLaunchFlagDisableSTDIO);
4216  else
4217  this_->m_launch_info.GetFlags().Clear(lldb::eLaunchFlagDisableSTDIO);
4218 }
4219 
4220 // Target::TargetEventData
4221 
4222 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp)
4223  : EventData(), m_target_sp(target_sp), m_module_list() {}
4224 
4225 Target::TargetEventData::TargetEventData(const lldb::TargetSP &target_sp,
4226  const ModuleList &module_list)
4227  : EventData(), m_target_sp(target_sp), m_module_list(module_list) {}
4228 
4230 
4232  static ConstString g_flavor("Target::TargetEventData");
4233  return g_flavor;
4234 }
4235 
4237  for (size_t i = 0; i < m_module_list.GetSize(); ++i) {
4238  if (i != 0)
4239  *s << ", ";
4240  m_module_list.GetModuleAtIndex(i)->GetDescription(
4242  }
4243 }
4244 
4247  if (event_ptr) {
4248  const EventData *event_data = event_ptr->GetData();
4249  if (event_data &&
4250  event_data->GetFlavor() == TargetEventData::GetFlavorString())
4251  return static_cast<const TargetEventData *>(event_ptr->GetData());
4252  }
4253  return nullptr;
4254 }
4255 
4257  TargetSP target_sp;
4258  const TargetEventData *event_data = GetEventDataFromEvent(event_ptr);
4259  if (event_data)
4260  target_sp = event_data->m_target_sp;
4261  return target_sp;
4262 }
4263 
4264 ModuleList
4266  ModuleList module_list;
4267  const TargetEventData *event_data = GetEventDataFromEvent(event_ptr);
4268  if (event_data)
4269  module_list = event_data->m_module_list;
4270  return module_list;
4271 }
static Status GetSharedModule(const ModuleSpec &module_spec, lldb::ModuleSP &module_sp, const FileSpecList *module_search_paths_ptr, lldb::ModuleSP *old_module_sp_ptr, bool *did_create_ptr, bool always_create=false)
Definition: ModuleList.cpp:765
A class to manage flag bits.
Definition: Debugger.h:82
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:369
size_t PutCString(llvm::StringRef cstr)
Output a C string to the stream.
Definition: Stream.cpp:61
virtual UtilityFunction * GetUtilityFunction(const char *text, const char *name)
Definition: TypeSystem.h:447
Status Attach(ProcessAttachInfo &attach_info, Stream *stream)
Definition: Target.cpp:2997
void SetSpecifier(SymbolContextSpecifier *specifier)
Definition: Target.cpp:3175
#define LLDB_WATCH_TYPE_READ
Definition: lldb-defines.h:57
lldb::TargetSP target_sp
The Target for a given query.
static bool IsWatchSizeSupported(uint32_t watch_size)
bool IsSectionOffset() const
Check if an address is section offset.
Definition: Address.h:330
llvm::StringRef GetArg0() const
Definition: ProcessInfo.cpp:76
An data extractor class.
Definition: DataExtractor.h:47
Environment GetEnvironment() const
Definition: Target.cpp:3836
A command line argument class.
Definition: Args.h:32
MemoryModuleLoadLevel GetMemoryModuleLoadLevel() const
Definition: Target.cpp:4054
const ArchSpec & GetSpec() const
Definition: Target.h:1262
#define LIBLLDB_LOG_OBJECT
Definition: Logging.h:25
bool EnableWatchpointByID(lldb::watch_id_t watch_id)
Definition: Target.cpp:1326
bool FindBreakpointsByName(const char *name, BreakpointList &matching_bps)
Find all the breakpoints with a given name.
void DisableAllowedBreakpoints()
Definition: Target.cpp:913
lldb::addr_t GetSectionLoadAddress(uint32_t stop_id, const lldb::SectionSP &section_sp)
bool RemoveBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:940
const ProcessLaunchInfo & GetProcessLaunchInfo()
Definition: Target.cpp:4101
void SetDefaultArchitecture(const ArchSpec &arch)
Definition: Target.cpp:3727
void AppendCurrentValue(const FileSpec &value)
#define LIBLLDB_LOG_PROCESS
Definition: Logging.h:15
void SetEventName(uint32_t event_mask, const char *name)
Set the name for an event bit.
Definition: Broadcaster.h:361
const char * StateAsCString(lldb::StateType state)
Converts a StateType to a C string.
Definition: State.cpp:14
Enumerations for broadcasting.
Definition: SBLaunchInfo.h:14
static void SettingsTerminate()
Definition: Process.cpp:4528
"lldb/Breakpoint/BreakpointResolverFileRegex.h" This class sets breakpoints by file and line...
lldb::PlatformSP GetSelectedPlatform()
Select the active platform.
Definition: Platform.h:958
bool ClearAllWatchpointHitCounts()
Definition: Target.cpp:1251
static constexpr PropertyDefinition g_experimental_properties[]
Definition: Target.cpp:3588
const ArchSpec & GetArchitecture() const
Definition: Target.h:941
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:224
int32_t break_id_t
Definition: lldb-types.h:88
void NotifyModulesRemoved(lldb_private::ModuleList &module_list) override
Definition: Target.cpp:1646
bool GetEnableAutoImportClangModules() const
Definition: Target.cpp:3902
ModuleList m_images
The list of images for this process (shared libraries and anything dynamically loaded).
Definition: Target.h:1275
lldb::StreamFileSP GetErrorFile()
Definition: Debugger.h:133
void SetExecutableFile(const FileSpec &exe_file, bool add_exe_file_as_first_arg)
Definition: ProcessInfo.cpp:61
void Clear()
Clear the object&#39;s state.
Definition: ModuleList.cpp:304
WatchpointList & GetWatchpointList()
Definition: Target.h:694
CommandInterpreter & GetCommandInterpreter()
Definition: Debugger.h:152
bool IsValid() const
Definition: UUID.h:65
void LogIfAnyCategoriesSet(uint32_t mask, const char *format,...)
Definition: Logging.cpp:66
A stream class that can stream formatted output to a file.
Definition: Stream.h:28
FileSpec GetStandardErrorPath() const
Definition: Target.cpp:3976
std::shared_ptr< Array > ArraySP
BreakpointList & GetBreakpointList(bool internal=false)
Definition: Target.cpp:283
virtual void CalculateExecutionContext(ExecutionContext &exe_ctx)=0
Reconstruct the object&#39;s execution context into sc.
void ConfigureBreakpoint(lldb::BreakpointSP bp_sp)
#define lldbassert(x)
Definition: LLDBAssert.h:15
"lldb/Breakpoint/BreakpointResolverAddress.h" This class sets breakpoints on a given Address...
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:531
bool SetPropertyAtIndexAsBoolean(const ExecutionContext *exe_ctx, uint32_t idx, bool new_value)
Process is currently trying to attach.
lldb::OptionValuePropertiesSP m_collection_sp
UserExpression * GetUserExpressionForLanguage(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj, Status &error)
Definition: Target.cpp:2217
Defines a symbol context baton that can be handed other debug core functions.
Definition: SymbolContext.h:33
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:742
TargetOptionValueProperties(ConstString name)
Definition: Target.cpp:3518
static ConstString & GetStaticBroadcasterClass()
Definition: Target.cpp:79
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:292
bool AppendSuppressFileAction(int fd, bool read, bool write)
lldb::TargetSP GetTargetSP()
Definition: Target.cpp:3551
size_t GetSize() const
Returns the number of elements in this breakpoint list.
bool IgnoreWatchpointByID(lldb::watch_id_t watch_id, uint32_t ignore_count)
Definition: Target.cpp:1363
General Outline: A breakpoint has four main parts, a filter, a resolver, the list of breakpoint locat...
Definition: Breakpoint.h:78
bool GetInjectLocalVariables(ExecutionContext *exe_ctx) const
Definition: Target.cpp:3683
bool ResolveFileAddress(lldb::addr_t vm_addr, Address &so_addr) const
Definition: ModuleList.cpp:649
void EnableAllBreakpoints(bool internal_also=false)
Definition: Target.cpp:921
void SetImmediateErrorStream(const lldb::StreamSP &stream_sp)
lldb::break_id_t GetBreakpointID() const
Definition: BreakpointID.h:30
bool GetDisplayRuntimeSupportValues() const
Definition: Target.cpp:4071
llvm::Error Error
void SetNonStopModeEnabled(bool b)
Definition: Target.cpp:4096
void SetAsyncExecution(bool async)
Definition: Debugger.cpp:875
#define LAUNCH_SHELL_MESSAGE
void NotifyWillClearList(const ModuleList &module_list) override
Definition: Target.cpp:1612
TypeSystem * GetTypeSystemForLanguage(lldb::LanguageType language, Module *module, bool can_create)
Definition: TypeSystem.cpp:201
~Target() override
Definition: Target.cpp:119
bool SetSectionUnloaded(uint32_t stop_id, const lldb::SectionSP &section_sp, lldb::addr_t load_addr)
virtual UserExpression * GetUserExpression(llvm::StringRef expr, llvm::StringRef prefix, lldb::LanguageType language, Expression::ResultType desired_type, const EvaluateExpressionOptions &options, ValueObject *ctx_obj)
Definition: TypeSystem.h:432
"lldb/Breakpoint/BreakpointResolverScripted.h" This class sets breakpoints on a given Address...
Encapsulates a one-time expression for use in lldb.
A shared library that can be used during execution.
Definition: ObjectFile.h:73
lldb::user_id_t GetID() const
Get accessor for the user ID.
Definition: UserID.h:49
lldb::WatchpointSP FindByID(lldb::watch_id_t watchID) const
Returns a shared pointer to the watchpoint with id watchID, const version.
const lldb::ProcessSP & CreateProcess(lldb::ListenerSP listener_sp, llvm::StringRef plugin_name, const FileSpec *crash_file)
Definition: Target.cpp:195
Status SerializeBreakpointsToFile(const FileSpec &file, const BreakpointIDList &bp_ids, bool append)
Definition: Target.cpp:1000
A mix in class that contains a generic user ID.
Definition: UserID.h:33
A file utility class.
Definition: FileSpec.h:55
"lldb/Utility/RegularExpression.h" A C++ wrapper class for regex.
void AppendExecutableSearchPaths(const FileSpec &)
Definition: Target.cpp:3866
An architecture specification class.
Definition: ArchSpec.h:32
bool GetEnableImportStdModule() const
Definition: Target.cpp:3908
bool RemoveWatchpointByID(lldb::watch_id_t watch_id)
Definition: Target.cpp:1346
void Dump(Stream *s, lldb::DescriptionLevel description_level)
Dump a description of this object to a Stream.
Definition: Target.cpp:148
bool m_suppress_stop_hooks
Definition: Target.h:1306
bool SetSectionLoadAddress(const lldb::SectionSP &section, lldb::addr_t load_addr, bool warn_multiple=false)
Definition: Target.cpp:2756
bool GetDisplayRecognizedArguments() const
Definition: Target.cpp:4081
A timer class that simplifies common timing metrics.
Definition: Timer.h:23
lldb::ExpressionResults EvaluateExpression(llvm::StringRef expression, ExecutionContextScope *exe_scope, lldb::ValueObjectSP &result_valobj_sp, const EvaluateExpressionOptions &options=EvaluateExpressionOptions(), std::string *fixed_expression=nullptr, ValueObject *ctx_obj=nullptr)
Definition: Target.cpp:2375
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:272
void SetEnabledAllowed(bool enabled)
A plug-in interface definition class for object file parsers.
Definition: ObjectFile.h:58
bool SetPreferDynamicValue(lldb::DynamicValueType d)
Definition: Target.cpp:3747
static ClangModulesDeclVendor * Create(Target &target)
"lldb/Target/ExecutionContext.h" A class that contains an execution context.
bool SetArchitecture(const ArchSpec &arch_spec, bool set_platform=false)
Set the architecture for this target.
Definition: Target.cpp:1498
lldb::StreamSP GetAsyncErrorStream()
Definition: Debugger.cpp:1153
size_t UnloadModuleSections(const lldb::ModuleSP &module_sp)
Definition: Target.cpp:2786
void SetIndentLevel(int level)
Set the current indentation level.
Definition: Stream.cpp:215
void SetInjectLocalVariables(ExecutionContext *exe_ctx, bool b)
Definition: Target.cpp:3696
bool ResolveFileAddress(lldb::addr_t load_addr, Address &so_addr)
Definition: Target.cpp:2751
int32_t watch_id_t
Definition: lldb-types.h:89
lldb::ListenerSP GetListener() const
lldb::ListenerSP GetListener()
Definition: Debugger.h:159
lldb::ProcessSP CalculateProcess() override
Definition: Target.cpp:2147
void RemoveInvalidLocations(const ArchSpec &arch)
Removes all invalid breakpoint locations.
Process or thread is stopped and can be examined.
lldb::BreakpointSP m_last_created_breakpoint
Definition: Target.h:1283
size_t GetIndexForModule(const Module *module) const
Definition: ModuleList.cpp:706
lldb::BreakpointSP FindBreakpointByID(lldb::break_id_t breakID) const
Returns a shared pointer to the breakpoint with id breakID.
const char * GetData() const
Definition: StreamString.h:43
bool IsValid() const
Tests if this ArchSpec is valid.
Definition: ArchSpec.h:329
static lldb::PlatformSP GetPlatformForArchitecture(const ArchSpec &arch, ArchSpec *platform_arch_ptr)
Definition: Platform.cpp:1186
The platform&#39;s dynamic linker executable.
Definition: ObjectFile.h:71
void UpdateBreakpoints(ModuleList &module_list, bool load, bool delete_locations)
Tell all the breakpoints to update themselves due to a change in the modules in module_list.
Debugger & m_debugger
Definition: Target.h:1270
#define LIBLLDB_LOG_WATCHPOINTS
Definition: Logging.h:20
Module * GetExecutableModulePointer()
Definition: Target.cpp:1394
void RemoveAll(bool notify)
Removes all the breakpoints from this list.
LoadDependentFiles
Definition: Target.h:59
lldb::addr_t GetCallableLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as a callable code load address for this target.
Definition: Target.cpp:2462
#define LLDB_LOG(log,...)
Definition: Log.h:209
SectionLoadHistory m_section_load_history
Definition: Target.h:1277
bool SetOffset(lldb::addr_t offset)
Set accessor for the offset.
Definition: Address.h:419
#define LLDB_LOG_ERROR(log, error,...)
Definition: Log.h:225
BreakpointList m_internal_breakpoint_list
Definition: Target.h:1279
lldb::ClangModulesDeclVendorUP m_clang_modules_decl_vendor_up
Definition: Target.h:1298
const BreakpointID & GetBreakpointIDAtIndex(size_t index) const
lldb::ModuleSP GetModule() const
Get const accessor for the module pointer.
Definition: ModuleChild.cpp:27
WatchpointList m_watchpoint_list
Definition: Target.h:1284
static void SettingsInitialize()
Definition: Process.cpp:4526
lldb::addr_t GetPersistentSymbol(ConstString name)
Definition: Target.cpp:2446
const char * GetProcessPluginName() const
Definition: Process.h:140
static lldb::REPLSP Create(Status &Status, lldb::LanguageType language, Debugger *debugger, Target *target, const char *repl_options)
Get a REPL with an existing target (or, failing that, a debugger to use), and (optional) extra argume...
Definition: REPL.cpp:35
bool GetDisplayExpressionsInCrashlogs() const
Definition: Target.cpp:4028
"lldb/Core/SearchFilter.h" This is a SearchFilter that searches through all modules.
Definition: SearchFilter.h:301
size_t GetSize() const
Returns the number of elements in this watchpoint list.
llvm::Triple & GetTriple()
Architecture triple accessor.
Definition: ArchSpec.h:431
void PiecewiseTripleCompare(const ArchSpec &other, bool &arch_different, bool &vendor_different, bool &os_different, bool &os_version_different, bool &env_different) const
Definition: ArchSpec.cpp:1411
void BroadcastEvent(lldb::EventSP &event_sp)
Broadcast an event which has no associated data.
Definition: Broadcaster.h:283
BreakpointName * FindBreakpointName(ConstString name, bool can_create, Status &error)
Definition: Target.cpp:701
void GetHostEnvironmentIfNeeded() const
Definition: Target.cpp:3554
static void GetLanguagesSupportingREPLs(std::set< lldb::LanguageType > &languages)
Definition: Language.cpp:344
FileSpec GetStandardInputPath() const
Definition: Target.cpp:3956
lldb::break_id_t Add(lldb::BreakpointSP &bp_sp, bool notify)
Add the breakpoint bp_sp to the list.
static void SettingsTerminate()
Definition: Target.cpp:2320
static ObjectSP ParseJSONFromFile(const FileSpec &file, Status &error)
ArchSpec GetDefaultArchitecture() const
Definition: Target.cpp:3719
StopHookSP GetStopHookByID(lldb::user_id_t uid)
Definition: Target.cpp:2519
BreakpointOptions & GetOptions()
lldb::StackFrameSP CalculateStackFrame() override
Definition: Target.cpp:2151
bool SignExtend(uint32_t bit_pos)
Definition: Scalar.cpp:2609
InlineStrategy GetInlineStrategy() const
Definition: Target.cpp:3807
void SetStandardInputPath(llvm::StringRef path)
Definition: Target.cpp:3961
Status Launch(ProcessLaunchInfo &launch_info, Stream *stream)
Definition: Target.cpp:2829
FunctionCaller * GetFunctionCallerForLanguage(lldb::LanguageType language, const CompilerType &return_type, const Address &function_address, const ValueList &arg_value_list, const char *name, Status &error)
Definition: Target.cpp:2246
Process has exited and can&#39;t be examined.
void DidExec()
Called as the last function in Process::DidExec().
Definition: Target.cpp:1425
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:317
lldb::DynamicValueType GetPreferDynamicValue() const
Definition: Target.cpp:3740
static void ImageSearchPathsChanged(const PathMappingList &path_list, void *baton)
Definition: Target.cpp:2162
void SetRunArguments(const Args &args)
Definition: Target.cpp:3830
virtual size_t ReadSectionData(Section *section, lldb::offset_t section_offset, void *dst, size_t dst_len)
Definition: ObjectFile.cpp:488
ConstString GetName() const
static const char * GetExperimentalSettingsName()
ValueType Clear(ValueType mask=~(ValueType) 0)
Clear one or more flags.
Definition: Flags.h:72
const char * GetArchitectureName() const
Returns a static string representing the current architecture.
Definition: ArchSpec.cpp:591
SourceManager & GetSourceManager()
Definition: Target.cpp:2482
lldb::ThreadSP GetThreadAtIndex(uint32_t idx, bool can_update=true)
Definition: ThreadList.cpp:90
static lldb::ListenerSP MakeListener(const char *name)
Definition: Listener.cpp:465
bool Remove(lldb::break_id_t breakID, bool notify)
Removes the breakpoint given by breakID from this list.
StopHookSP CreateStopHook()
Definition: Target.cpp:2505
Target * GetTargetPtr() const
Returns a pointer to the target object.
void SetArg0(llvm::StringRef arg)
Definition: ProcessInfo.cpp:78
void Dump(Stream *s) const
Dump the description of each module contained in this list.
Definition: ModuleList.cpp:620
StopHookCollection m_stop_hooks
Definition: Target.h:1303
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
size_t ReadMemoryFromFileCache(const Address &addr, void *dst, size_t dst_len, Status &error)
Definition: Target.cpp:1729
lldb::StreamSP GetAsyncOutputStream()
Definition: Debugger.cpp:1149
uint64_t user_id_t
Definition: lldb-types.h:84
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:86
lldb::BreakpointSP GetBreakpointByID(lldb::break_id_t break_id)
Definition: Target.cpp:297
LanguageType
Programming language type.
const lldb::WatchpointSP FindByAddress(lldb::addr_t addr) const
Returns a shared pointer to the watchpoint at address addr - const version.
const lldb::ProcessSP & GetProcessSP() const
Definition: Target.cpp:206
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
Definition: ModuleList.cpp:326
StopHook(const StopHook &rhs)
Definition: Target.cpp:3164
void SetEnabledAll(bool enabled)
lldb::BreakpointSP CreateSourceRegexBreakpoint(const FileSpecList *containingModules, const FileSpecList *source_file_list, const std::unordered_set< std::string > &function_names, RegularExpression &source_regex, bool internal, bool request_hardware, LazyBool move_to_nearest_code)
Definition: Target.cpp:308
void Append(const lldb::ModuleSP &module_sp, bool notify=true)
Append a module to the module list.
void Dump(Stream *s) const override
Definition: Target.cpp:4236
lldb::addr_t GetBreakableLoadAddress(lldb::addr_t addr)
Definition: Target.cpp:2476
bool Test(ValueType bit) const
Test a single flag bit.
Definition: Flags.h:107
bool GetUserSpecifiedTrapHandlerNames(Args &args) const
Definition: Target.cpp:4061
bool GetEnableSyntheticValue() const
Definition: Target.cpp:3932
static ModuleList GetModuleListFromEvent(const Event *event_ptr)
Definition: Target.cpp:4265
TargetOptionValueProperties(Target *target, const TargetPropertiesSP &target_properties_sp)
Definition: Target.cpp:3524
bool IsSourceImplementationFile() const
Returns true if the filespec represents an implementation source file (files with a "...
Definition: FileSpec.cpp:490
void SetAllStopHooksActiveState(bool active_state)
Definition: Target.cpp:2540
int GetIndentLevel() const
Get the current indentation level.
Definition: Stream.cpp:212
uint64_t offset_t
Definition: lldb-types.h:87
void AppendPathComponent(llvm::StringRef component)
Definition: FileSpec.cpp:463
PathMappingList m_image_search_paths
Definition: Target.h:1291
lldb::ListenerSP GetListenerForProcess(Debugger &debugger)
Definition: Process.cpp:2786
lldb::PlatformSP m_platform_sp
The platform for this target.
Definition: Target.h:1271
bool ReadPointerFromMemory(const Address &addr, bool prefer_file_cache, Status &error, Address &pointer_addr)
Definition: Target.cpp:1969
lldb::SearchFilterSP m_search_filter_sp
Definition: Target.h:1290
An object file that contains only debug information.
Definition: ObjectFile.h:70
Log * GetLogIfAllCategoriesSet(uint32_t mask)
Definition: Logging.cpp:57
An intermediate object file.
Definition: ObjectFile.h:72
std::recursive_mutex m_mutex
An API mutex that is used by the lldb::SB* classes make the SB interface thread safe.
Definition: Target.h:1272
uint64_t ReadUnsignedIntegerFromMemory(const Address &addr, bool prefer_file_cache, size_t integer_byte_size, uint64_t fail_value, Status &error)
Definition: Target.cpp:1957
const char * GetStringAtIndex(size_t idx) const
Definition: StringList.cpp:82
A collection class for Module objects.
Definition: ModuleList.h:91
static FileSpecList GetDefaultClangModuleSearchPaths()
Definition: Target.cpp:2336
lldb::ThreadSP CalculateThread() override
Definition: Target.cpp:2149
bool GetUseHexImmediates() const
Definition: Target.cpp:4016
bool GetRequireHardwareBreakpoints() const
Definition: Target.cpp:4132
void DeleteBreakpointName(ConstString name)
Definition: Target.cpp:726
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1012
bool SetSectionLoadAddress(uint32_t stop_id, const lldb::SectionSP &section_sp, lldb::addr_t load_addr, bool warn_multiple=false)
bool AppendOpenFileAction(int fd, const FileSpec &file_spec, bool read, bool write)
A class that describes an executable image and its associated object and symbol files.
Definition: Module.h:109
#define LIBLLDB_LOG_BREAKPOINTS
Definition: Logging.h:19
Process is connected to remote debug services, but not launched or attached to anything yet...
void Dump(Stream &s, bool pretty_print=true) const override
static FileSpecList GetDefaultDebugFileSearchPaths()
Definition: Target.cpp:2329
void MergeInto(const Permissions &incoming)
lldb::REPLSP GetREPL(Status &err, lldb::LanguageType language, const char *repl_options, bool can_create)
Definition: Target.cpp:208
lldb::BreakpointSP CreateAddressInModuleBreakpoint(lldb::addr_t file_addr, bool internal, const FileSpec *file_spec, bool request_hardware)
Definition: Target.cpp:406
llvm::StringRef GetExpressionPrefixContents()
Definition: Target.cpp:3995
lldb::ModuleSP FindFirstModule(const ModuleSpec &module_spec) const
Definition: ModuleList.cpp:599
void SetHijackListener(const lldb::ListenerSP &listener_sp)
virtual void SymbolsDidLoad(const ModuleList &module_list)
void Clear()
Clear the object state.
Definition: Status.cpp:167
void SymbolsDidLoad(ModuleList &module_list)
Definition: Target.cpp:1668
uint32_t GetMaximumNumberOfChildrenToDisplay() const
Definition: Target.cpp:3938
TypeSystem * GetScratchTypeSystemForLanguage(Status *error, lldb::LanguageType language, bool create_on_demand=true)
Definition: Target.cpp:2170
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
bool EnableAllWatchpoints(bool end_to_end=true)
Definition: Target.cpp:1222
lldb::ModuleSP GetOrCreateModule(const ModuleSpec &module_spec, bool notify, Status *error_ptr=nullptr)
Find a binary on the system and return its Module, or return an existing Module that is already in th...
Definition: Target.cpp:1999
bool ProcessInfoSpecified() const
Definition: Process.h:155
ObjectSP GetValueForKey(llvm::StringRef key) const
void SetStandardOutputPath(llvm::StringRef path)
Definition: Target.cpp:3971
void SetImmediateOutputStream(const lldb::StreamSP &stream_sp)
void SetStandardErrorPath(llvm::StringRef path)
Definition: Target.cpp:3981
Encapsulates a function that can be called.
llvm::StringRef GetString() const
PathMappingList & GetImageSearchPathList()
Definition: Target.cpp:2158
size_t ReadScalarIntegerFromMemory(const Address &addr, bool prefer_file_cache, uint32_t byte_size, bool is_signed, Scalar &scalar, Status &error)
Definition: Target.cpp:1928
void ApplyNameToBreakpoints(BreakpointName &bp_name)
Definition: Target.cpp:753
void ConfigureBreakpointName(BreakpointName &bp_name, const BreakpointOptions &options, const BreakpointName::Permissions &permissions)
Definition: Target.cpp:744
static lldb::TargetSP GetTargetFromEvent(const Event *event_ptr)
Definition: Target.cpp:4256
unsigned long long ULongLong(unsigned long long fail_value=0) const
Definition: Scalar.cpp:1566
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
void SetErrorString(llvm::StringRef err_str)
Set the current error string to err_str.
Definition: Status.cpp:241
"lldb/Target/ExecutionContextScope.h" Inherit from this if your object can reconstruct its execution ...
void CopyOverSetOptions(const BreakpointOptions &rhs)
Copy over only the options set in the incoming BreakpointOptions.
const char * GetDisassemblyFlavor() const
Definition: Target.cpp:3796
Environment & GetEnvironment()
Definition: ProcessInfo.h:88
static constexpr OptionEnumValueElement g_memory_module_load_level_values[]
Definition: Target.cpp:3286
lldb::addr_t GetOpcodeLoadAddress(lldb::addr_t load_addr, AddressClass addr_class=AddressClass::eInvalid) const
Get load_addr as an opcode for this target.
Definition: Target.cpp:2469
x86DisassemblyFlavor
Definition: Target.cpp:3254
static std::unique_ptr< Architecture > CreateArchitectureInstance(const ArchSpec &arch)
lldb::ByteOrder GetByteOrder() const
Returns the byte order for the architecture specification.
Definition: ArchSpec.cpp:788
lldb::SectionSP GetSectionAtIndex(size_t idx) const
Definition: Section.cpp:497
void IndentLess(int amount=2)
Decrement the current indentation level.
Definition: Stream.cpp:221
static FileSpecList GetDefaultExecutableSearchPaths()
Definition: