1 //===-- Target.cpp ----------------------------------------------*- C++ -*-===//
2 //
3 // The LLVM Compiler Infrastructure
4 //
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9
10 #include "lldb/lldb-python.h"
11
12 #include "lldb/Target/Target.h"
13
14 // C Includes
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/Breakpoint/BreakpointResolver.h"
19 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
20 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
21 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
22 #include "lldb/Breakpoint/BreakpointResolverName.h"
23 #include "lldb/Breakpoint/Watchpoint.h"
24 #include "lldb/Core/Debugger.h"
25 #include "lldb/Core/Event.h"
26 #include "lldb/Core/Log.h"
27 #include "lldb/Core/Module.h"
28 #include "lldb/Core/ModuleSpec.h"
29 #include "lldb/Core/Section.h"
30 #include "lldb/Core/SourceManager.h"
31 #include "lldb/Core/StreamString.h"
32 #include "lldb/Core/Timer.h"
33 #include "lldb/Core/ValueObject.h"
34 #include "lldb/Expression/ClangASTSource.h"
35 #include "lldb/Expression/ClangUserExpression.h"
36 #include "lldb/Host/Host.h"
37 #include "lldb/Interpreter/CommandInterpreter.h"
38 #include "lldb/Interpreter/CommandReturnObject.h"
39 #include "lldb/Interpreter/OptionGroupWatchpoint.h"
40 #include "lldb/Interpreter/OptionValues.h"
41 #include "lldb/Interpreter/Property.h"
42 #include "lldb/lldb-private-log.h"
43 #include "lldb/Symbol/ObjectFile.h"
44 #include "lldb/Target/Process.h"
45 #include "lldb/Target/StackFrame.h"
46 #include "lldb/Target/Thread.h"
47 #include "lldb/Target/ThreadSpec.h"
48
49 using namespace lldb;
50 using namespace lldb_private;
51
52 ConstString &
GetStaticBroadcasterClass()53 Target::GetStaticBroadcasterClass ()
54 {
55 static ConstString class_name ("lldb.target");
56 return class_name;
57 }
58
59 //----------------------------------------------------------------------
60 // Target constructor
61 //----------------------------------------------------------------------
Target(Debugger & debugger,const ArchSpec & target_arch,const lldb::PlatformSP & platform_sp)62 Target::Target(Debugger &debugger, const ArchSpec &target_arch, const lldb::PlatformSP &platform_sp) :
63 TargetProperties (this),
64 Broadcaster (&debugger, Target::GetStaticBroadcasterClass().AsCString()),
65 ExecutionContextScope (),
66 m_debugger (debugger),
67 m_platform_sp (platform_sp),
68 m_mutex (Mutex::eMutexTypeRecursive),
69 m_arch (target_arch),
70 m_images (this),
71 m_section_load_list (),
72 m_breakpoint_list (false),
73 m_internal_breakpoint_list (true),
74 m_watchpoint_list (),
75 m_process_sp (),
76 m_valid (true),
77 m_search_filter_sp (),
78 m_image_search_paths (ImageSearchPathsChanged, this),
79 m_scratch_ast_context_ap (),
80 m_scratch_ast_source_ap (),
81 m_ast_importer_ap (),
82 m_persistent_variables (),
83 m_source_manager_ap(),
84 m_stop_hooks (),
85 m_stop_hook_next_id (0),
86 m_suppress_stop_hooks (false),
87 m_suppress_synthetic_value(false)
88 {
89 SetEventName (eBroadcastBitBreakpointChanged, "breakpoint-changed");
90 SetEventName (eBroadcastBitModulesLoaded, "modules-loaded");
91 SetEventName (eBroadcastBitModulesUnloaded, "modules-unloaded");
92 SetEventName (eBroadcastBitWatchpointChanged, "watchpoint-changed");
93 SetEventName (eBroadcastBitSymbolsLoaded, "symbols-loaded");
94
95 CheckInWithManager();
96
97 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
98 if (log)
99 log->Printf ("%p Target::Target()", this);
100 if (m_arch.IsValid())
101 {
102 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::Target created with architecture %s (%s)", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
103 }
104 }
105
106 //----------------------------------------------------------------------
107 // Destructor
108 //----------------------------------------------------------------------
~Target()109 Target::~Target()
110 {
111 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
112 if (log)
113 log->Printf ("%p Target::~Target()", this);
114 DeleteCurrentProcess ();
115 }
116
117 void
Dump(Stream * s,lldb::DescriptionLevel description_level)118 Target::Dump (Stream *s, lldb::DescriptionLevel description_level)
119 {
120 // s->Printf("%.*p: ", (int)sizeof(void*) * 2, this);
121 if (description_level != lldb::eDescriptionLevelBrief)
122 {
123 s->Indent();
124 s->PutCString("Target\n");
125 s->IndentMore();
126 m_images.Dump(s);
127 m_breakpoint_list.Dump(s);
128 m_internal_breakpoint_list.Dump(s);
129 s->IndentLess();
130 }
131 else
132 {
133 Module *exe_module = GetExecutableModulePointer();
134 if (exe_module)
135 s->PutCString (exe_module->GetFileSpec().GetFilename().GetCString());
136 else
137 s->PutCString ("No executable module.");
138 }
139 }
140
141 void
CleanupProcess()142 Target::CleanupProcess ()
143 {
144 // Do any cleanup of the target we need to do between process instances.
145 // NB It is better to do this before destroying the process in case the
146 // clean up needs some help from the process.
147 m_breakpoint_list.ClearAllBreakpointSites();
148 m_internal_breakpoint_list.ClearAllBreakpointSites();
149 // Disable watchpoints just on the debugger side.
150 Mutex::Locker locker;
151 this->GetWatchpointList().GetListMutex(locker);
152 DisableAllWatchpoints(false);
153 ClearAllWatchpointHitCounts();
154 }
155
156 void
DeleteCurrentProcess()157 Target::DeleteCurrentProcess ()
158 {
159 if (m_process_sp.get())
160 {
161 m_section_load_list.Clear();
162 if (m_process_sp->IsAlive())
163 m_process_sp->Destroy();
164
165 m_process_sp->Finalize();
166
167 CleanupProcess ();
168
169 m_process_sp.reset();
170 }
171 }
172
173 const lldb::ProcessSP &
CreateProcess(Listener & listener,const char * plugin_name,const FileSpec * crash_file)174 Target::CreateProcess (Listener &listener, const char *plugin_name, const FileSpec *crash_file)
175 {
176 DeleteCurrentProcess ();
177 m_process_sp = Process::FindPlugin(*this, plugin_name, listener, crash_file);
178 return m_process_sp;
179 }
180
181 const lldb::ProcessSP &
GetProcessSP() const182 Target::GetProcessSP () const
183 {
184 return m_process_sp;
185 }
186
187 void
Destroy()188 Target::Destroy()
189 {
190 Mutex::Locker locker (m_mutex);
191 m_valid = false;
192 DeleteCurrentProcess ();
193 m_platform_sp.reset();
194 m_arch.Clear();
195 m_images.Clear();
196 m_section_load_list.Clear();
197 const bool notify = false;
198 m_breakpoint_list.RemoveAll(notify);
199 m_internal_breakpoint_list.RemoveAll(notify);
200 m_last_created_breakpoint.reset();
201 m_last_created_watchpoint.reset();
202 m_search_filter_sp.reset();
203 m_image_search_paths.Clear(notify);
204 m_scratch_ast_context_ap.reset();
205 m_scratch_ast_source_ap.reset();
206 m_ast_importer_ap.reset();
207 m_persistent_variables.Clear();
208 m_stop_hooks.clear();
209 m_stop_hook_next_id = 0;
210 m_suppress_stop_hooks = false;
211 m_suppress_synthetic_value = false;
212 }
213
214
215 BreakpointList &
GetBreakpointList(bool internal)216 Target::GetBreakpointList(bool internal)
217 {
218 if (internal)
219 return m_internal_breakpoint_list;
220 else
221 return m_breakpoint_list;
222 }
223
224 const BreakpointList &
GetBreakpointList(bool internal) const225 Target::GetBreakpointList(bool internal) const
226 {
227 if (internal)
228 return m_internal_breakpoint_list;
229 else
230 return m_breakpoint_list;
231 }
232
233 BreakpointSP
GetBreakpointByID(break_id_t break_id)234 Target::GetBreakpointByID (break_id_t break_id)
235 {
236 BreakpointSP bp_sp;
237
238 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
239 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
240 else
241 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
242
243 return bp_sp;
244 }
245
246 BreakpointSP
CreateSourceRegexBreakpoint(const FileSpecList * containingModules,const FileSpecList * source_file_spec_list,RegularExpression & source_regex,bool internal)247 Target::CreateSourceRegexBreakpoint (const FileSpecList *containingModules,
248 const FileSpecList *source_file_spec_list,
249 RegularExpression &source_regex,
250 bool internal)
251 {
252 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, source_file_spec_list));
253 BreakpointResolverSP resolver_sp(new BreakpointResolverFileRegex (NULL, source_regex));
254 return CreateBreakpoint (filter_sp, resolver_sp, internal);
255 }
256
257
258 BreakpointSP
CreateBreakpoint(const FileSpecList * containingModules,const FileSpec & file,uint32_t line_no,LazyBool check_inlines,LazyBool skip_prologue,bool internal)259 Target::CreateBreakpoint (const FileSpecList *containingModules,
260 const FileSpec &file,
261 uint32_t line_no,
262 LazyBool check_inlines,
263 LazyBool skip_prologue,
264 bool internal)
265 {
266 if (check_inlines == eLazyBoolCalculate)
267 {
268 const InlineStrategy inline_strategy = GetInlineStrategy();
269 switch (inline_strategy)
270 {
271 case eInlineBreakpointsNever:
272 check_inlines = eLazyBoolNo;
273 break;
274
275 case eInlineBreakpointsHeaders:
276 if (file.IsSourceImplementationFile())
277 check_inlines = eLazyBoolNo;
278 else
279 check_inlines = eLazyBoolYes;
280 break;
281
282 case eInlineBreakpointsAlways:
283 check_inlines = eLazyBoolYes;
284 break;
285 }
286 }
287 SearchFilterSP filter_sp;
288 if (check_inlines == eLazyBoolNo)
289 {
290 // Not checking for inlines, we are looking only for matching compile units
291 FileSpecList compile_unit_list;
292 compile_unit_list.Append (file);
293 filter_sp = GetSearchFilterForModuleAndCUList (containingModules, &compile_unit_list);
294 }
295 else
296 {
297 filter_sp = GetSearchFilterForModuleList (containingModules);
298 }
299 if (skip_prologue == eLazyBoolCalculate)
300 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
301
302 BreakpointResolverSP resolver_sp(new BreakpointResolverFileLine (NULL,
303 file,
304 line_no,
305 check_inlines,
306 skip_prologue));
307 return CreateBreakpoint (filter_sp, resolver_sp, internal);
308 }
309
310
311 BreakpointSP
CreateBreakpoint(lldb::addr_t addr,bool internal)312 Target::CreateBreakpoint (lldb::addr_t addr, bool internal)
313 {
314 Address so_addr;
315 // Attempt to resolve our load address if possible, though it is ok if
316 // it doesn't resolve to section/offset.
317
318 // Try and resolve as a load address if possible
319 m_section_load_list.ResolveLoadAddress(addr, so_addr);
320 if (!so_addr.IsValid())
321 {
322 // The address didn't resolve, so just set this as an absolute address
323 so_addr.SetOffset (addr);
324 }
325 BreakpointSP bp_sp (CreateBreakpoint(so_addr, internal));
326 return bp_sp;
327 }
328
329 BreakpointSP
CreateBreakpoint(Address & addr,bool internal)330 Target::CreateBreakpoint (Address &addr, bool internal)
331 {
332 SearchFilterSP filter_sp(new SearchFilterForNonModuleSpecificSearches (shared_from_this()));
333 BreakpointResolverSP resolver_sp (new BreakpointResolverAddress (NULL, addr));
334 return CreateBreakpoint (filter_sp, resolver_sp, internal);
335 }
336
337 BreakpointSP
CreateBreakpoint(const FileSpecList * containingModules,const FileSpecList * containingSourceFiles,const char * func_name,uint32_t func_name_type_mask,LazyBool skip_prologue,bool internal)338 Target::CreateBreakpoint (const FileSpecList *containingModules,
339 const FileSpecList *containingSourceFiles,
340 const char *func_name,
341 uint32_t func_name_type_mask,
342 LazyBool skip_prologue,
343 bool internal)
344 {
345 BreakpointSP bp_sp;
346 if (func_name)
347 {
348 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
349
350 if (skip_prologue == eLazyBoolCalculate)
351 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
352
353 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
354 func_name,
355 func_name_type_mask,
356 Breakpoint::Exact,
357 skip_prologue));
358 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal);
359 }
360 return bp_sp;
361 }
362
363 lldb::BreakpointSP
CreateBreakpoint(const FileSpecList * containingModules,const FileSpecList * containingSourceFiles,const std::vector<std::string> & func_names,uint32_t func_name_type_mask,LazyBool skip_prologue,bool internal)364 Target::CreateBreakpoint (const FileSpecList *containingModules,
365 const FileSpecList *containingSourceFiles,
366 const std::vector<std::string> &func_names,
367 uint32_t func_name_type_mask,
368 LazyBool skip_prologue,
369 bool internal)
370 {
371 BreakpointSP bp_sp;
372 size_t num_names = func_names.size();
373 if (num_names > 0)
374 {
375 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
376
377 if (skip_prologue == eLazyBoolCalculate)
378 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
379
380 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
381 func_names,
382 func_name_type_mask,
383 skip_prologue));
384 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal);
385 }
386 return bp_sp;
387 }
388
389 BreakpointSP
CreateBreakpoint(const FileSpecList * containingModules,const FileSpecList * containingSourceFiles,const char * func_names[],size_t num_names,uint32_t func_name_type_mask,LazyBool skip_prologue,bool internal)390 Target::CreateBreakpoint (const FileSpecList *containingModules,
391 const FileSpecList *containingSourceFiles,
392 const char *func_names[],
393 size_t num_names,
394 uint32_t func_name_type_mask,
395 LazyBool skip_prologue,
396 bool internal)
397 {
398 BreakpointSP bp_sp;
399 if (num_names > 0)
400 {
401 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
402
403 if (skip_prologue == eLazyBoolCalculate)
404 skip_prologue = GetSkipPrologue() ? eLazyBoolYes : eLazyBoolNo;
405
406 BreakpointResolverSP resolver_sp (new BreakpointResolverName (NULL,
407 func_names,
408 num_names,
409 func_name_type_mask,
410 skip_prologue));
411 bp_sp = CreateBreakpoint (filter_sp, resolver_sp, internal);
412 }
413 return bp_sp;
414 }
415
416 SearchFilterSP
GetSearchFilterForModule(const FileSpec * containingModule)417 Target::GetSearchFilterForModule (const FileSpec *containingModule)
418 {
419 SearchFilterSP filter_sp;
420 if (containingModule != NULL)
421 {
422 // TODO: We should look into sharing module based search filters
423 // across many breakpoints like we do for the simple target based one
424 filter_sp.reset (new SearchFilterByModule (shared_from_this(), *containingModule));
425 }
426 else
427 {
428 if (m_search_filter_sp.get() == NULL)
429 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this()));
430 filter_sp = m_search_filter_sp;
431 }
432 return filter_sp;
433 }
434
435 SearchFilterSP
GetSearchFilterForModuleList(const FileSpecList * containingModules)436 Target::GetSearchFilterForModuleList (const FileSpecList *containingModules)
437 {
438 SearchFilterSP filter_sp;
439 if (containingModules && containingModules->GetSize() != 0)
440 {
441 // TODO: We should look into sharing module based search filters
442 // across many breakpoints like we do for the simple target based one
443 filter_sp.reset (new SearchFilterByModuleList (shared_from_this(), *containingModules));
444 }
445 else
446 {
447 if (m_search_filter_sp.get() == NULL)
448 m_search_filter_sp.reset (new SearchFilterForNonModuleSpecificSearches (shared_from_this()));
449 filter_sp = m_search_filter_sp;
450 }
451 return filter_sp;
452 }
453
454 SearchFilterSP
GetSearchFilterForModuleAndCUList(const FileSpecList * containingModules,const FileSpecList * containingSourceFiles)455 Target::GetSearchFilterForModuleAndCUList (const FileSpecList *containingModules,
456 const FileSpecList *containingSourceFiles)
457 {
458 if (containingSourceFiles == NULL || containingSourceFiles->GetSize() == 0)
459 return GetSearchFilterForModuleList(containingModules);
460
461 SearchFilterSP filter_sp;
462 if (containingModules == NULL)
463 {
464 // We could make a special "CU List only SearchFilter". Better yet was if these could be composable,
465 // but that will take a little reworking.
466
467 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), FileSpecList(), *containingSourceFiles));
468 }
469 else
470 {
471 filter_sp.reset (new SearchFilterByModuleListAndCU (shared_from_this(), *containingModules, *containingSourceFiles));
472 }
473 return filter_sp;
474 }
475
476 BreakpointSP
CreateFuncRegexBreakpoint(const FileSpecList * containingModules,const FileSpecList * containingSourceFiles,RegularExpression & func_regex,LazyBool skip_prologue,bool internal)477 Target::CreateFuncRegexBreakpoint (const FileSpecList *containingModules,
478 const FileSpecList *containingSourceFiles,
479 RegularExpression &func_regex,
480 LazyBool skip_prologue,
481 bool internal)
482 {
483 SearchFilterSP filter_sp(GetSearchFilterForModuleAndCUList (containingModules, containingSourceFiles));
484 BreakpointResolverSP resolver_sp(new BreakpointResolverName (NULL,
485 func_regex,
486 skip_prologue == eLazyBoolCalculate ? GetSkipPrologue() : skip_prologue));
487
488 return CreateBreakpoint (filter_sp, resolver_sp, internal);
489 }
490
491 lldb::BreakpointSP
CreateExceptionBreakpoint(enum lldb::LanguageType language,bool catch_bp,bool throw_bp,bool internal)492 Target::CreateExceptionBreakpoint (enum lldb::LanguageType language, bool catch_bp, bool throw_bp, bool internal)
493 {
494 return LanguageRuntime::CreateExceptionBreakpoint (*this, language, catch_bp, throw_bp, internal);
495 }
496
497 BreakpointSP
CreateBreakpoint(SearchFilterSP & filter_sp,BreakpointResolverSP & resolver_sp,bool internal)498 Target::CreateBreakpoint (SearchFilterSP &filter_sp, BreakpointResolverSP &resolver_sp, bool internal)
499 {
500 BreakpointSP bp_sp;
501 if (filter_sp && resolver_sp)
502 {
503 bp_sp.reset(new Breakpoint (*this, filter_sp, resolver_sp));
504 resolver_sp->SetBreakpoint (bp_sp.get());
505
506 if (internal)
507 m_internal_breakpoint_list.Add (bp_sp, false);
508 else
509 m_breakpoint_list.Add (bp_sp, true);
510
511 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
512 if (log)
513 {
514 StreamString s;
515 bp_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
516 log->Printf ("Target::%s (internal = %s) => break_id = %s\n", __FUNCTION__, internal ? "yes" : "no", s.GetData());
517 }
518
519 bp_sp->ResolveBreakpoint();
520 }
521
522 if (!internal && bp_sp)
523 {
524 m_last_created_breakpoint = bp_sp;
525 }
526
527 return bp_sp;
528 }
529
530 bool
ProcessIsValid()531 Target::ProcessIsValid()
532 {
533 return (m_process_sp && m_process_sp->IsAlive());
534 }
535
536 static bool
CheckIfWatchpointsExhausted(Target * target,Error & error)537 CheckIfWatchpointsExhausted(Target *target, Error &error)
538 {
539 uint32_t num_supported_hardware_watchpoints;
540 Error rc = target->GetProcessSP()->GetWatchpointSupportInfo(num_supported_hardware_watchpoints);
541 if (rc.Success())
542 {
543 uint32_t num_current_watchpoints = target->GetWatchpointList().GetSize();
544 if (num_current_watchpoints >= num_supported_hardware_watchpoints)
545 error.SetErrorStringWithFormat("number of supported hardware watchpoints (%u) has been reached",
546 num_supported_hardware_watchpoints);
547 }
548 return false;
549 }
550
551 // See also Watchpoint::SetWatchpointType(uint32_t type) and
552 // the OptionGroupWatchpoint::WatchType enum type.
553 WatchpointSP
CreateWatchpoint(lldb::addr_t addr,size_t size,const ClangASTType * type,uint32_t kind,Error & error)554 Target::CreateWatchpoint(lldb::addr_t addr, size_t size, const ClangASTType *type, uint32_t kind, Error &error)
555 {
556 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
557 if (log)
558 log->Printf("Target::%s (addr = 0x%8.8" PRIx64 " size = %" PRIu64 " type = %u)\n",
559 __FUNCTION__, addr, (uint64_t)size, kind);
560
561 WatchpointSP wp_sp;
562 if (!ProcessIsValid())
563 {
564 error.SetErrorString("process is not alive");
565 return wp_sp;
566 }
567
568 if (addr == LLDB_INVALID_ADDRESS || size == 0)
569 {
570 if (size == 0)
571 error.SetErrorString("cannot set a watchpoint with watch_size of 0");
572 else
573 error.SetErrorStringWithFormat("invalid watch address: %" PRIu64, addr);
574 return wp_sp;
575 }
576
577 if (!LLDB_WATCH_TYPE_IS_VALID(kind))
578 {
579 error.SetErrorStringWithFormat ("invalid watchpoint type: %d", kind);
580 }
581
582 // Currently we only support one watchpoint per address, with total number
583 // of watchpoints limited by the hardware which the inferior is running on.
584
585 // Grab the list mutex while doing operations.
586 const bool notify = false; // Don't notify about all the state changes we do on creating the watchpoint.
587 Mutex::Locker locker;
588 this->GetWatchpointList().GetListMutex(locker);
589 WatchpointSP matched_sp = m_watchpoint_list.FindByAddress(addr);
590 if (matched_sp)
591 {
592 size_t old_size = matched_sp->GetByteSize();
593 uint32_t old_type =
594 (matched_sp->WatchpointRead() ? LLDB_WATCH_TYPE_READ : 0) |
595 (matched_sp->WatchpointWrite() ? LLDB_WATCH_TYPE_WRITE : 0);
596 // Return the existing watchpoint if both size and type match.
597 if (size == old_size && kind == old_type)
598 {
599 wp_sp = matched_sp;
600 wp_sp->SetEnabled(false, notify);
601 }
602 else
603 {
604 // Nil the matched watchpoint; we will be creating a new one.
605 m_process_sp->DisableWatchpoint(matched_sp.get(), notify);
606 m_watchpoint_list.Remove(matched_sp->GetID(), true);
607 }
608 }
609
610 if (!wp_sp)
611 {
612 wp_sp.reset(new Watchpoint(*this, addr, size, type));
613 wp_sp->SetWatchpointType(kind, notify);
614 m_watchpoint_list.Add (wp_sp, true);
615 }
616
617 error = m_process_sp->EnableWatchpoint(wp_sp.get(), notify);
618 if (log)
619 log->Printf("Target::%s (creation of watchpoint %s with id = %u)\n",
620 __FUNCTION__,
621 error.Success() ? "succeeded" : "failed",
622 wp_sp->GetID());
623
624 if (error.Fail())
625 {
626 // Enabling the watchpoint on the device side failed.
627 // Remove the said watchpoint from the list maintained by the target instance.
628 m_watchpoint_list.Remove (wp_sp->GetID(), true);
629 // See if we could provide more helpful error message.
630 if (!CheckIfWatchpointsExhausted(this, error))
631 {
632 if (!OptionGroupWatchpoint::IsWatchSizeSupported(size))
633 error.SetErrorStringWithFormat("watch size of %lu is not supported", size);
634 }
635 wp_sp.reset();
636 }
637 else
638 m_last_created_watchpoint = wp_sp;
639 return wp_sp;
640 }
641
642 void
RemoveAllBreakpoints(bool internal_also)643 Target::RemoveAllBreakpoints (bool internal_also)
644 {
645 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
646 if (log)
647 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
648
649 m_breakpoint_list.RemoveAll (true);
650 if (internal_also)
651 m_internal_breakpoint_list.RemoveAll (false);
652
653 m_last_created_breakpoint.reset();
654 }
655
656 void
DisableAllBreakpoints(bool internal_also)657 Target::DisableAllBreakpoints (bool internal_also)
658 {
659 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
660 if (log)
661 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
662
663 m_breakpoint_list.SetEnabledAll (false);
664 if (internal_also)
665 m_internal_breakpoint_list.SetEnabledAll (false);
666 }
667
668 void
EnableAllBreakpoints(bool internal_also)669 Target::EnableAllBreakpoints (bool internal_also)
670 {
671 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
672 if (log)
673 log->Printf ("Target::%s (internal_also = %s)\n", __FUNCTION__, internal_also ? "yes" : "no");
674
675 m_breakpoint_list.SetEnabledAll (true);
676 if (internal_also)
677 m_internal_breakpoint_list.SetEnabledAll (true);
678 }
679
680 bool
RemoveBreakpointByID(break_id_t break_id)681 Target::RemoveBreakpointByID (break_id_t break_id)
682 {
683 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
684 if (log)
685 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
686
687 if (DisableBreakpointByID (break_id))
688 {
689 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
690 m_internal_breakpoint_list.Remove(break_id, false);
691 else
692 {
693 if (m_last_created_breakpoint)
694 {
695 if (m_last_created_breakpoint->GetID() == break_id)
696 m_last_created_breakpoint.reset();
697 }
698 m_breakpoint_list.Remove(break_id, true);
699 }
700 return true;
701 }
702 return false;
703 }
704
705 bool
DisableBreakpointByID(break_id_t break_id)706 Target::DisableBreakpointByID (break_id_t break_id)
707 {
708 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
709 if (log)
710 log->Printf ("Target::%s (break_id = %i, internal = %s)\n", __FUNCTION__, break_id, LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
711
712 BreakpointSP bp_sp;
713
714 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
715 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
716 else
717 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
718 if (bp_sp)
719 {
720 bp_sp->SetEnabled (false);
721 return true;
722 }
723 return false;
724 }
725
726 bool
EnableBreakpointByID(break_id_t break_id)727 Target::EnableBreakpointByID (break_id_t break_id)
728 {
729 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
730 if (log)
731 log->Printf ("Target::%s (break_id = %i, internal = %s)\n",
732 __FUNCTION__,
733 break_id,
734 LLDB_BREAK_ID_IS_INTERNAL (break_id) ? "yes" : "no");
735
736 BreakpointSP bp_sp;
737
738 if (LLDB_BREAK_ID_IS_INTERNAL (break_id))
739 bp_sp = m_internal_breakpoint_list.FindBreakpointByID (break_id);
740 else
741 bp_sp = m_breakpoint_list.FindBreakpointByID (break_id);
742
743 if (bp_sp)
744 {
745 bp_sp->SetEnabled (true);
746 return true;
747 }
748 return false;
749 }
750
751 // The flag 'end_to_end', default to true, signifies that the operation is
752 // performed end to end, for both the debugger and the debuggee.
753
754 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end
755 // to end operations.
756 bool
RemoveAllWatchpoints(bool end_to_end)757 Target::RemoveAllWatchpoints (bool end_to_end)
758 {
759 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
760 if (log)
761 log->Printf ("Target::%s\n", __FUNCTION__);
762
763 if (!end_to_end) {
764 m_watchpoint_list.RemoveAll(true);
765 return true;
766 }
767
768 // Otherwise, it's an end to end operation.
769
770 if (!ProcessIsValid())
771 return false;
772
773 size_t num_watchpoints = m_watchpoint_list.GetSize();
774 for (size_t i = 0; i < num_watchpoints; ++i)
775 {
776 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
777 if (!wp_sp)
778 return false;
779
780 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
781 if (rc.Fail())
782 return false;
783 }
784 m_watchpoint_list.RemoveAll (true);
785 m_last_created_watchpoint.reset();
786 return true; // Success!
787 }
788
789 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
790 // end operations.
791 bool
DisableAllWatchpoints(bool end_to_end)792 Target::DisableAllWatchpoints (bool end_to_end)
793 {
794 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
795 if (log)
796 log->Printf ("Target::%s\n", __FUNCTION__);
797
798 if (!end_to_end) {
799 m_watchpoint_list.SetEnabledAll(false);
800 return true;
801 }
802
803 // Otherwise, it's an end to end operation.
804
805 if (!ProcessIsValid())
806 return false;
807
808 size_t num_watchpoints = m_watchpoint_list.GetSize();
809 for (size_t i = 0; i < num_watchpoints; ++i)
810 {
811 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
812 if (!wp_sp)
813 return false;
814
815 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
816 if (rc.Fail())
817 return false;
818 }
819 return true; // Success!
820 }
821
822 // Assumption: Caller holds the list mutex lock for m_watchpoint_list for end to
823 // end operations.
824 bool
EnableAllWatchpoints(bool end_to_end)825 Target::EnableAllWatchpoints (bool end_to_end)
826 {
827 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
828 if (log)
829 log->Printf ("Target::%s\n", __FUNCTION__);
830
831 if (!end_to_end) {
832 m_watchpoint_list.SetEnabledAll(true);
833 return true;
834 }
835
836 // Otherwise, it's an end to end operation.
837
838 if (!ProcessIsValid())
839 return false;
840
841 size_t num_watchpoints = m_watchpoint_list.GetSize();
842 for (size_t i = 0; i < num_watchpoints; ++i)
843 {
844 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
845 if (!wp_sp)
846 return false;
847
848 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
849 if (rc.Fail())
850 return false;
851 }
852 return true; // Success!
853 }
854
855 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
856 bool
ClearAllWatchpointHitCounts()857 Target::ClearAllWatchpointHitCounts ()
858 {
859 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
860 if (log)
861 log->Printf ("Target::%s\n", __FUNCTION__);
862
863 size_t num_watchpoints = m_watchpoint_list.GetSize();
864 for (size_t i = 0; i < num_watchpoints; ++i)
865 {
866 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
867 if (!wp_sp)
868 return false;
869
870 wp_sp->ResetHitCount();
871 }
872 return true; // Success!
873 }
874
875 // Assumption: Caller holds the list mutex lock for m_watchpoint_list
876 // during these operations.
877 bool
IgnoreAllWatchpoints(uint32_t ignore_count)878 Target::IgnoreAllWatchpoints (uint32_t ignore_count)
879 {
880 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
881 if (log)
882 log->Printf ("Target::%s\n", __FUNCTION__);
883
884 if (!ProcessIsValid())
885 return false;
886
887 size_t num_watchpoints = m_watchpoint_list.GetSize();
888 for (size_t i = 0; i < num_watchpoints; ++i)
889 {
890 WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
891 if (!wp_sp)
892 return false;
893
894 wp_sp->SetIgnoreCount(ignore_count);
895 }
896 return true; // Success!
897 }
898
899 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
900 bool
DisableWatchpointByID(lldb::watch_id_t watch_id)901 Target::DisableWatchpointByID (lldb::watch_id_t watch_id)
902 {
903 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
904 if (log)
905 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
906
907 if (!ProcessIsValid())
908 return false;
909
910 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
911 if (wp_sp)
912 {
913 Error rc = m_process_sp->DisableWatchpoint(wp_sp.get());
914 if (rc.Success())
915 return true;
916
917 // Else, fallthrough.
918 }
919 return false;
920 }
921
922 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
923 bool
EnableWatchpointByID(lldb::watch_id_t watch_id)924 Target::EnableWatchpointByID (lldb::watch_id_t watch_id)
925 {
926 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
927 if (log)
928 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
929
930 if (!ProcessIsValid())
931 return false;
932
933 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
934 if (wp_sp)
935 {
936 Error rc = m_process_sp->EnableWatchpoint(wp_sp.get());
937 if (rc.Success())
938 return true;
939
940 // Else, fallthrough.
941 }
942 return false;
943 }
944
945 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
946 bool
RemoveWatchpointByID(lldb::watch_id_t watch_id)947 Target::RemoveWatchpointByID (lldb::watch_id_t watch_id)
948 {
949 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
950 if (log)
951 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
952
953 WatchpointSP watch_to_remove_sp = m_watchpoint_list.FindByID(watch_id);
954 if (watch_to_remove_sp == m_last_created_watchpoint)
955 m_last_created_watchpoint.reset();
956
957 if (DisableWatchpointByID (watch_id))
958 {
959 m_watchpoint_list.Remove(watch_id, true);
960 return true;
961 }
962 return false;
963 }
964
965 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
966 bool
IgnoreWatchpointByID(lldb::watch_id_t watch_id,uint32_t ignore_count)967 Target::IgnoreWatchpointByID (lldb::watch_id_t watch_id, uint32_t ignore_count)
968 {
969 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_WATCHPOINTS));
970 if (log)
971 log->Printf ("Target::%s (watch_id = %i)\n", __FUNCTION__, watch_id);
972
973 if (!ProcessIsValid())
974 return false;
975
976 WatchpointSP wp_sp = m_watchpoint_list.FindByID (watch_id);
977 if (wp_sp)
978 {
979 wp_sp->SetIgnoreCount(ignore_count);
980 return true;
981 }
982 return false;
983 }
984
985 ModuleSP
GetExecutableModule()986 Target::GetExecutableModule ()
987 {
988 return m_images.GetModuleAtIndex(0);
989 }
990
991 Module*
GetExecutableModulePointer()992 Target::GetExecutableModulePointer ()
993 {
994 return m_images.GetModulePointerAtIndex(0);
995 }
996
997 static void
LoadScriptingResourceForModule(const ModuleSP & module_sp,Target * target)998 LoadScriptingResourceForModule (const ModuleSP &module_sp, Target *target)
999 {
1000 Error error;
1001 StreamString feedback_stream;
1002 if (module_sp && !module_sp->LoadScriptingResourceInTarget(target, error, &feedback_stream))
1003 {
1004 if (error.AsCString())
1005 target->GetDebugger().GetErrorStream().Printf("unable to load scripting data for module %s - error reported was %s\n",
1006 module_sp->GetFileSpec().GetFileNameStrippingExtension().GetCString(),
1007 error.AsCString());
1008 if (feedback_stream.GetSize())
1009 target->GetDebugger().GetOutputStream().Printf("%s\n",
1010 feedback_stream.GetData());
1011 }
1012 }
1013
1014 void
SetExecutableModule(ModuleSP & executable_sp,bool get_dependent_files)1015 Target::SetExecutableModule (ModuleSP& executable_sp, bool get_dependent_files)
1016 {
1017 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1018 m_images.Clear();
1019 m_scratch_ast_context_ap.reset();
1020 m_scratch_ast_source_ap.reset();
1021 m_ast_importer_ap.reset();
1022
1023 if (executable_sp.get())
1024 {
1025 Timer scoped_timer (__PRETTY_FUNCTION__,
1026 "Target::SetExecutableModule (executable = '%s')",
1027 executable_sp->GetFileSpec().GetPath().c_str());
1028
1029 m_images.Append(executable_sp); // The first image is our exectuable file
1030
1031 // If we haven't set an architecture yet, reset our architecture based on what we found in the executable module.
1032 if (!m_arch.IsValid())
1033 {
1034 m_arch = executable_sp->GetArchitecture();
1035 if (log)
1036 log->Printf ("Target::SetExecutableModule setting architecture to %s (%s) based on executable file", m_arch.GetArchitectureName(), m_arch.GetTriple().getTriple().c_str());
1037 }
1038
1039 FileSpecList dependent_files;
1040 ObjectFile *executable_objfile = executable_sp->GetObjectFile();
1041
1042 if (executable_objfile && get_dependent_files)
1043 {
1044 executable_objfile->GetDependentModules(dependent_files);
1045 for (uint32_t i=0; i<dependent_files.GetSize(); i++)
1046 {
1047 FileSpec dependent_file_spec (dependent_files.GetFileSpecPointerAtIndex(i));
1048 FileSpec platform_dependent_file_spec;
1049 if (m_platform_sp)
1050 m_platform_sp->GetFile (dependent_file_spec, NULL, platform_dependent_file_spec);
1051 else
1052 platform_dependent_file_spec = dependent_file_spec;
1053
1054 ModuleSpec module_spec (platform_dependent_file_spec, m_arch);
1055 ModuleSP image_module_sp(GetSharedModule (module_spec));
1056 if (image_module_sp.get())
1057 {
1058 ObjectFile *objfile = image_module_sp->GetObjectFile();
1059 if (objfile)
1060 objfile->GetDependentModules(dependent_files);
1061 }
1062 }
1063 }
1064 }
1065 }
1066
1067
1068 bool
SetArchitecture(const ArchSpec & arch_spec)1069 Target::SetArchitecture (const ArchSpec &arch_spec)
1070 {
1071 Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_TARGET));
1072 if (m_arch.IsCompatibleMatch(arch_spec) || !m_arch.IsValid())
1073 {
1074 // If we haven't got a valid arch spec, or the architectures are
1075 // compatible, so just update the architecture. Architectures can be
1076 // equal, yet the triple OS and vendor might change, so we need to do
1077 // the assignment here just in case.
1078 m_arch = arch_spec;
1079 if (log)
1080 log->Printf ("Target::SetArchitecture setting architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1081 return true;
1082 }
1083 else
1084 {
1085 // If we have an executable file, try to reset the executable to the desired architecture
1086 if (log)
1087 log->Printf ("Target::SetArchitecture changing architecture to %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1088 m_arch = arch_spec;
1089 ModuleSP executable_sp = GetExecutableModule ();
1090 m_images.Clear();
1091 m_scratch_ast_context_ap.reset();
1092 m_scratch_ast_source_ap.reset();
1093 m_ast_importer_ap.reset();
1094 // Need to do something about unsetting breakpoints.
1095
1096 if (executable_sp)
1097 {
1098 if (log)
1099 log->Printf("Target::SetArchitecture Trying to select executable file architecture %s (%s)", arch_spec.GetArchitectureName(), arch_spec.GetTriple().getTriple().c_str());
1100 ModuleSpec module_spec (executable_sp->GetFileSpec(), arch_spec);
1101 Error error = ModuleList::GetSharedModule (module_spec,
1102 executable_sp,
1103 &GetExecutableSearchPaths(),
1104 NULL,
1105 NULL);
1106
1107 if (!error.Fail() && executable_sp)
1108 {
1109 SetExecutableModule (executable_sp, true);
1110 return true;
1111 }
1112 }
1113 }
1114 return false;
1115 }
1116
1117 void
WillClearList(const ModuleList & module_list)1118 Target::WillClearList (const ModuleList& module_list)
1119 {
1120 }
1121
1122 void
ModuleAdded(const ModuleList & module_list,const ModuleSP & module_sp)1123 Target::ModuleAdded (const ModuleList& module_list, const ModuleSP &module_sp)
1124 {
1125 // A module is being added to this target for the first time
1126 ModuleList my_module_list;
1127 my_module_list.Append(module_sp);
1128 LoadScriptingResourceForModule(module_sp, this);
1129 ModulesDidLoad (my_module_list);
1130 }
1131
1132 void
ModuleRemoved(const ModuleList & module_list,const ModuleSP & module_sp)1133 Target::ModuleRemoved (const ModuleList& module_list, const ModuleSP &module_sp)
1134 {
1135 // A module is being added to this target for the first time
1136 ModuleList my_module_list;
1137 my_module_list.Append(module_sp);
1138 ModulesDidUnload (my_module_list);
1139 }
1140
1141 void
ModuleUpdated(const ModuleList & module_list,const ModuleSP & old_module_sp,const ModuleSP & new_module_sp)1142 Target::ModuleUpdated (const ModuleList& module_list, const ModuleSP &old_module_sp, const ModuleSP &new_module_sp)
1143 {
1144 // A module is replacing an already added module
1145 m_breakpoint_list.UpdateBreakpointsWhenModuleIsReplaced(old_module_sp, new_module_sp);
1146 }
1147
1148 void
ModulesDidLoad(ModuleList & module_list)1149 Target::ModulesDidLoad (ModuleList &module_list)
1150 {
1151 if (module_list.GetSize())
1152 {
1153 m_breakpoint_list.UpdateBreakpoints (module_list, true);
1154 // TODO: make event data that packages up the module_list
1155 BroadcastEvent (eBroadcastBitModulesLoaded, NULL);
1156 }
1157 }
1158
1159 void
SymbolsDidLoad(ModuleList & module_list)1160 Target::SymbolsDidLoad (ModuleList &module_list)
1161 {
1162 if (module_list.GetSize())
1163 {
1164 if (m_process_sp)
1165 {
1166 LanguageRuntime* runtime = m_process_sp->GetLanguageRuntime(lldb::eLanguageTypeObjC);
1167 if (runtime)
1168 {
1169 ObjCLanguageRuntime *objc_runtime = (ObjCLanguageRuntime*)runtime;
1170 objc_runtime->SymbolsDidLoad(module_list);
1171 }
1172 }
1173
1174 m_breakpoint_list.UpdateBreakpoints (module_list, true);
1175 BroadcastEvent(eBroadcastBitSymbolsLoaded, NULL);
1176 }
1177 }
1178
1179 void
ModulesDidUnload(ModuleList & module_list)1180 Target::ModulesDidUnload (ModuleList &module_list)
1181 {
1182 if (module_list.GetSize())
1183 {
1184 m_breakpoint_list.UpdateBreakpoints (module_list, false);
1185 // TODO: make event data that packages up the module_list
1186 BroadcastEvent (eBroadcastBitModulesUnloaded, NULL);
1187 }
1188 }
1189
1190 bool
ModuleIsExcludedForNonModuleSpecificSearches(const FileSpec & module_file_spec)1191 Target::ModuleIsExcludedForNonModuleSpecificSearches (const FileSpec &module_file_spec)
1192 {
1193 if (GetBreakpointsConsultPlatformAvoidList())
1194 {
1195 ModuleList matchingModules;
1196 ModuleSpec module_spec (module_file_spec);
1197 size_t num_modules = GetImages().FindModules(module_spec, matchingModules);
1198
1199 // If there is more than one module for this file spec, only return true if ALL the modules are on the
1200 // black list.
1201 if (num_modules > 0)
1202 {
1203 for (size_t i = 0; i < num_modules; i++)
1204 {
1205 if (!ModuleIsExcludedForNonModuleSpecificSearches (matchingModules.GetModuleAtIndex(i)))
1206 return false;
1207 }
1208 return true;
1209 }
1210 }
1211 return false;
1212 }
1213
1214 bool
ModuleIsExcludedForNonModuleSpecificSearches(const lldb::ModuleSP & module_sp)1215 Target::ModuleIsExcludedForNonModuleSpecificSearches (const lldb::ModuleSP &module_sp)
1216 {
1217 if (GetBreakpointsConsultPlatformAvoidList())
1218 {
1219 if (m_platform_sp)
1220 return m_platform_sp->ModuleIsExcludedForNonModuleSpecificSearches (*this, module_sp);
1221 }
1222 return false;
1223 }
1224
1225 size_t
ReadMemoryFromFileCache(const Address & addr,void * dst,size_t dst_len,Error & error)1226 Target::ReadMemoryFromFileCache (const Address& addr, void *dst, size_t dst_len, Error &error)
1227 {
1228 SectionSP section_sp (addr.GetSection());
1229 if (section_sp)
1230 {
1231 // If the contents of this section are encrypted, the on-disk file is unusuable. Read only from live memory.
1232 if (section_sp->IsEncrypted())
1233 {
1234 error.SetErrorString("section is encrypted");
1235 return 0;
1236 }
1237 ModuleSP module_sp (section_sp->GetModule());
1238 if (module_sp)
1239 {
1240 ObjectFile *objfile = section_sp->GetModule()->GetObjectFile();
1241 if (objfile)
1242 {
1243 size_t bytes_read = objfile->ReadSectionData (section_sp.get(),
1244 addr.GetOffset(),
1245 dst,
1246 dst_len);
1247 if (bytes_read > 0)
1248 return bytes_read;
1249 else
1250 error.SetErrorStringWithFormat("error reading data from section %s", section_sp->GetName().GetCString());
1251 }
1252 else
1253 error.SetErrorString("address isn't from a object file");
1254 }
1255 else
1256 error.SetErrorString("address isn't in a module");
1257 }
1258 else
1259 error.SetErrorString("address doesn't contain a section that points to a section in a object file");
1260
1261 return 0;
1262 }
1263
1264 size_t
ReadMemory(const Address & addr,bool prefer_file_cache,void * dst,size_t dst_len,Error & error,lldb::addr_t * load_addr_ptr)1265 Target::ReadMemory (const Address& addr,
1266 bool prefer_file_cache,
1267 void *dst,
1268 size_t dst_len,
1269 Error &error,
1270 lldb::addr_t *load_addr_ptr)
1271 {
1272 error.Clear();
1273
1274 // if we end up reading this from process memory, we will fill this
1275 // with the actual load address
1276 if (load_addr_ptr)
1277 *load_addr_ptr = LLDB_INVALID_ADDRESS;
1278
1279 size_t bytes_read = 0;
1280
1281 addr_t load_addr = LLDB_INVALID_ADDRESS;
1282 addr_t file_addr = LLDB_INVALID_ADDRESS;
1283 Address resolved_addr;
1284 if (!addr.IsSectionOffset())
1285 {
1286 if (m_section_load_list.IsEmpty())
1287 {
1288 // No sections are loaded, so we must assume we are not running
1289 // yet and anything we are given is a file address.
1290 file_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the file address
1291 m_images.ResolveFileAddress (file_addr, resolved_addr);
1292 }
1293 else
1294 {
1295 // We have at least one section loaded. This can be becuase
1296 // we have manually loaded some sections with "target modules load ..."
1297 // or because we have have a live process that has sections loaded
1298 // through the dynamic loader
1299 load_addr = addr.GetOffset(); // "addr" doesn't have a section, so its offset is the load address
1300 m_section_load_list.ResolveLoadAddress (load_addr, resolved_addr);
1301 }
1302 }
1303 if (!resolved_addr.IsValid())
1304 resolved_addr = addr;
1305
1306
1307 if (prefer_file_cache)
1308 {
1309 bytes_read = ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1310 if (bytes_read > 0)
1311 return bytes_read;
1312 }
1313
1314 if (ProcessIsValid())
1315 {
1316 if (load_addr == LLDB_INVALID_ADDRESS)
1317 load_addr = resolved_addr.GetLoadAddress (this);
1318
1319 if (load_addr == LLDB_INVALID_ADDRESS)
1320 {
1321 ModuleSP addr_module_sp (resolved_addr.GetModule());
1322 if (addr_module_sp && addr_module_sp->GetFileSpec())
1323 error.SetErrorStringWithFormat("%s[0x%" PRIx64 "] can't be resolved, %s in not currently loaded",
1324 addr_module_sp->GetFileSpec().GetFilename().AsCString(),
1325 resolved_addr.GetFileAddress(),
1326 addr_module_sp->GetFileSpec().GetFilename().AsCString());
1327 else
1328 error.SetErrorStringWithFormat("0x%" PRIx64 " can't be resolved", resolved_addr.GetFileAddress());
1329 }
1330 else
1331 {
1332 bytes_read = m_process_sp->ReadMemory(load_addr, dst, dst_len, error);
1333 if (bytes_read != dst_len)
1334 {
1335 if (error.Success())
1336 {
1337 if (bytes_read == 0)
1338 error.SetErrorStringWithFormat("read memory from 0x%" PRIx64 " failed", load_addr);
1339 else
1340 error.SetErrorStringWithFormat("only %" PRIu64 " of %" PRIu64 " bytes were read from memory at 0x%" PRIx64, (uint64_t)bytes_read, (uint64_t)dst_len, load_addr);
1341 }
1342 }
1343 if (bytes_read)
1344 {
1345 if (load_addr_ptr)
1346 *load_addr_ptr = load_addr;
1347 return bytes_read;
1348 }
1349 // If the address is not section offset we have an address that
1350 // doesn't resolve to any address in any currently loaded shared
1351 // libaries and we failed to read memory so there isn't anything
1352 // more we can do. If it is section offset, we might be able to
1353 // read cached memory from the object file.
1354 if (!resolved_addr.IsSectionOffset())
1355 return 0;
1356 }
1357 }
1358
1359 if (!prefer_file_cache && resolved_addr.IsSectionOffset())
1360 {
1361 // If we didn't already try and read from the object file cache, then
1362 // try it after failing to read from the process.
1363 return ReadMemoryFromFileCache (resolved_addr, dst, dst_len, error);
1364 }
1365 return 0;
1366 }
1367
1368 size_t
ReadCStringFromMemory(const Address & addr,std::string & out_str,Error & error)1369 Target::ReadCStringFromMemory (const Address& addr, std::string &out_str, Error &error)
1370 {
1371 char buf[256];
1372 out_str.clear();
1373 addr_t curr_addr = addr.GetLoadAddress(this);
1374 Address address(addr);
1375 while (1)
1376 {
1377 size_t length = ReadCStringFromMemory (address, buf, sizeof(buf), error);
1378 if (length == 0)
1379 break;
1380 out_str.append(buf, length);
1381 // If we got "length - 1" bytes, we didn't get the whole C string, we
1382 // need to read some more characters
1383 if (length == sizeof(buf) - 1)
1384 curr_addr += length;
1385 else
1386 break;
1387 address = Address(curr_addr);
1388 }
1389 return out_str.size();
1390 }
1391
1392
1393 size_t
ReadCStringFromMemory(const Address & addr,char * dst,size_t dst_max_len,Error & result_error)1394 Target::ReadCStringFromMemory (const Address& addr, char *dst, size_t dst_max_len, Error &result_error)
1395 {
1396 size_t total_cstr_len = 0;
1397 if (dst && dst_max_len)
1398 {
1399 result_error.Clear();
1400 // NULL out everything just to be safe
1401 memset (dst, 0, dst_max_len);
1402 Error error;
1403 addr_t curr_addr = addr.GetLoadAddress(this);
1404 Address address(addr);
1405 const size_t cache_line_size = 512;
1406 size_t bytes_left = dst_max_len - 1;
1407 char *curr_dst = dst;
1408
1409 while (bytes_left > 0)
1410 {
1411 addr_t cache_line_bytes_left = cache_line_size - (curr_addr % cache_line_size);
1412 addr_t bytes_to_read = std::min<addr_t>(bytes_left, cache_line_bytes_left);
1413 size_t bytes_read = ReadMemory (address, false, curr_dst, bytes_to_read, error);
1414
1415 if (bytes_read == 0)
1416 {
1417 result_error = error;
1418 dst[total_cstr_len] = '\0';
1419 break;
1420 }
1421 const size_t len = strlen(curr_dst);
1422
1423 total_cstr_len += len;
1424
1425 if (len < bytes_to_read)
1426 break;
1427
1428 curr_dst += bytes_read;
1429 curr_addr += bytes_read;
1430 bytes_left -= bytes_read;
1431 address = Address(curr_addr);
1432 }
1433 }
1434 else
1435 {
1436 if (dst == NULL)
1437 result_error.SetErrorString("invalid arguments");
1438 else
1439 result_error.Clear();
1440 }
1441 return total_cstr_len;
1442 }
1443
1444 size_t
ReadScalarIntegerFromMemory(const Address & addr,bool prefer_file_cache,uint32_t byte_size,bool is_signed,Scalar & scalar,Error & error)1445 Target::ReadScalarIntegerFromMemory (const Address& addr,
1446 bool prefer_file_cache,
1447 uint32_t byte_size,
1448 bool is_signed,
1449 Scalar &scalar,
1450 Error &error)
1451 {
1452 uint64_t uval;
1453
1454 if (byte_size <= sizeof(uval))
1455 {
1456 size_t bytes_read = ReadMemory (addr, prefer_file_cache, &uval, byte_size, error);
1457 if (bytes_read == byte_size)
1458 {
1459 DataExtractor data (&uval, sizeof(uval), m_arch.GetByteOrder(), m_arch.GetAddressByteSize());
1460 lldb::offset_t offset = 0;
1461 if (byte_size <= 4)
1462 scalar = data.GetMaxU32 (&offset, byte_size);
1463 else
1464 scalar = data.GetMaxU64 (&offset, byte_size);
1465
1466 if (is_signed)
1467 scalar.SignExtend(byte_size * 8);
1468 return bytes_read;
1469 }
1470 }
1471 else
1472 {
1473 error.SetErrorStringWithFormat ("byte size of %u is too large for integer scalar type", byte_size);
1474 }
1475 return 0;
1476 }
1477
1478 uint64_t
ReadUnsignedIntegerFromMemory(const Address & addr,bool prefer_file_cache,size_t integer_byte_size,uint64_t fail_value,Error & error)1479 Target::ReadUnsignedIntegerFromMemory (const Address& addr,
1480 bool prefer_file_cache,
1481 size_t integer_byte_size,
1482 uint64_t fail_value,
1483 Error &error)
1484 {
1485 Scalar scalar;
1486 if (ReadScalarIntegerFromMemory (addr,
1487 prefer_file_cache,
1488 integer_byte_size,
1489 false,
1490 scalar,
1491 error))
1492 return scalar.ULongLong(fail_value);
1493 return fail_value;
1494 }
1495
1496 bool
ReadPointerFromMemory(const Address & addr,bool prefer_file_cache,Error & error,Address & pointer_addr)1497 Target::ReadPointerFromMemory (const Address& addr,
1498 bool prefer_file_cache,
1499 Error &error,
1500 Address &pointer_addr)
1501 {
1502 Scalar scalar;
1503 if (ReadScalarIntegerFromMemory (addr,
1504 prefer_file_cache,
1505 m_arch.GetAddressByteSize(),
1506 false,
1507 scalar,
1508 error))
1509 {
1510 addr_t pointer_vm_addr = scalar.ULongLong(LLDB_INVALID_ADDRESS);
1511 if (pointer_vm_addr != LLDB_INVALID_ADDRESS)
1512 {
1513 if (m_section_load_list.IsEmpty())
1514 {
1515 // No sections are loaded, so we must assume we are not running
1516 // yet and anything we are given is a file address.
1517 m_images.ResolveFileAddress (pointer_vm_addr, pointer_addr);
1518 }
1519 else
1520 {
1521 // We have at least one section loaded. This can be becuase
1522 // we have manually loaded some sections with "target modules load ..."
1523 // or because we have have a live process that has sections loaded
1524 // through the dynamic loader
1525 m_section_load_list.ResolveLoadAddress (pointer_vm_addr, pointer_addr);
1526 }
1527 // We weren't able to resolve the pointer value, so just return
1528 // an address with no section
1529 if (!pointer_addr.IsValid())
1530 pointer_addr.SetOffset (pointer_vm_addr);
1531 return true;
1532
1533 }
1534 }
1535 return false;
1536 }
1537
1538 ModuleSP
GetSharedModule(const ModuleSpec & module_spec,Error * error_ptr)1539 Target::GetSharedModule (const ModuleSpec &module_spec, Error *error_ptr)
1540 {
1541 ModuleSP module_sp;
1542
1543 Error error;
1544
1545 // First see if we already have this module in our module list. If we do, then we're done, we don't need
1546 // to consult the shared modules list. But only do this if we are passed a UUID.
1547
1548 if (module_spec.GetUUID().IsValid())
1549 module_sp = m_images.FindFirstModule(module_spec);
1550
1551 if (!module_sp)
1552 {
1553 ModuleSP old_module_sp; // This will get filled in if we have a new version of the library
1554 bool did_create_module = false;
1555
1556 // If there are image search path entries, try to use them first to acquire a suitable image.
1557 if (m_image_search_paths.GetSize())
1558 {
1559 ModuleSpec transformed_spec (module_spec);
1560 if (m_image_search_paths.RemapPath (module_spec.GetFileSpec().GetDirectory(), transformed_spec.GetFileSpec().GetDirectory()))
1561 {
1562 transformed_spec.GetFileSpec().GetFilename() = module_spec.GetFileSpec().GetFilename();
1563 error = ModuleList::GetSharedModule (transformed_spec,
1564 module_sp,
1565 &GetExecutableSearchPaths(),
1566 &old_module_sp,
1567 &did_create_module);
1568 }
1569 }
1570
1571 if (!module_sp)
1572 {
1573 // If we have a UUID, we can check our global shared module list in case
1574 // we already have it. If we don't have a valid UUID, then we can't since
1575 // the path in "module_spec" will be a platform path, and we will need to
1576 // let the platform find that file. For example, we could be asking for
1577 // "/usr/lib/dyld" and if we do not have a UUID, we don't want to pick
1578 // the local copy of "/usr/lib/dyld" since our platform could be a remote
1579 // platform that has its own "/usr/lib/dyld" in an SDK or in a local file
1580 // cache.
1581 if (module_spec.GetUUID().IsValid())
1582 {
1583 // We have a UUID, it is OK to check the global module list...
1584 error = ModuleList::GetSharedModule (module_spec,
1585 module_sp,
1586 &GetExecutableSearchPaths(),
1587 &old_module_sp,
1588 &did_create_module);
1589 }
1590
1591 if (!module_sp)
1592 {
1593 // The platform is responsible for finding and caching an appropriate
1594 // module in the shared module cache.
1595 if (m_platform_sp)
1596 {
1597 FileSpec platform_file_spec;
1598 error = m_platform_sp->GetSharedModule (module_spec,
1599 module_sp,
1600 &GetExecutableSearchPaths(),
1601 &old_module_sp,
1602 &did_create_module);
1603 }
1604 else
1605 {
1606 error.SetErrorString("no platform is currently set");
1607 }
1608 }
1609 }
1610
1611 // We found a module that wasn't in our target list. Let's make sure that there wasn't an equivalent
1612 // module in the list already, and if there was, let's remove it.
1613 if (module_sp)
1614 {
1615 ObjectFile *objfile = module_sp->GetObjectFile();
1616 if (objfile)
1617 {
1618 switch (objfile->GetType())
1619 {
1620 case ObjectFile::eTypeCoreFile: /// A core file that has a checkpoint of a program's execution state
1621 case ObjectFile::eTypeExecutable: /// A normal executable
1622 case ObjectFile::eTypeDynamicLinker: /// The platform's dynamic linker executable
1623 case ObjectFile::eTypeObjectFile: /// An intermediate object file
1624 case ObjectFile::eTypeSharedLibrary: /// A shared library that can be used during execution
1625 break;
1626 case ObjectFile::eTypeDebugInfo: /// An object file that contains only debug information
1627 if (error_ptr)
1628 error_ptr->SetErrorString("debug info files aren't valid target modules, please specify an executable");
1629 return ModuleSP();
1630 case ObjectFile::eTypeStubLibrary: /// A library that can be linked against but not used for execution
1631 if (error_ptr)
1632 error_ptr->SetErrorString("stub libraries aren't valid target modules, please specify an executable");
1633 return ModuleSP();
1634 default:
1635 if (error_ptr)
1636 error_ptr->SetErrorString("unsupported file type, please specify an executable");
1637 return ModuleSP();
1638 }
1639 // GetSharedModule is not guaranteed to find the old shared module, for instance
1640 // in the common case where you pass in the UUID, it is only going to find the one
1641 // module matching the UUID. In fact, it has no good way to know what the "old module"
1642 // relevant to this target is, since there might be many copies of a module with this file spec
1643 // in various running debug sessions, but only one of them will belong to this target.
1644 // So let's remove the UUID from the module list, and look in the target's module list.
1645 // Only do this if there is SOMETHING else in the module spec...
1646 if (!old_module_sp)
1647 {
1648 if (module_spec.GetUUID().IsValid() && !module_spec.GetFileSpec().GetFilename().IsEmpty() && !module_spec.GetFileSpec().GetDirectory().IsEmpty())
1649 {
1650 ModuleSpec module_spec_copy(module_spec.GetFileSpec());
1651 module_spec_copy.GetUUID().Clear();
1652
1653 ModuleList found_modules;
1654 size_t num_found = m_images.FindModules (module_spec_copy, found_modules);
1655 if (num_found == 1)
1656 {
1657 old_module_sp = found_modules.GetModuleAtIndex(0);
1658 }
1659 }
1660 }
1661
1662 if (old_module_sp && m_images.GetIndexForModule (old_module_sp.get()) != LLDB_INVALID_INDEX32)
1663 {
1664 m_images.ReplaceModule(old_module_sp, module_sp);
1665 Module *old_module_ptr = old_module_sp.get();
1666 old_module_sp.reset();
1667 ModuleList::RemoveSharedModuleIfOrphaned (old_module_ptr);
1668 }
1669 else
1670 m_images.Append(module_sp);
1671 }
1672 }
1673 }
1674 if (error_ptr)
1675 *error_ptr = error;
1676 return module_sp;
1677 }
1678
1679
1680 TargetSP
CalculateTarget()1681 Target::CalculateTarget ()
1682 {
1683 return shared_from_this();
1684 }
1685
1686 ProcessSP
CalculateProcess()1687 Target::CalculateProcess ()
1688 {
1689 return ProcessSP();
1690 }
1691
1692 ThreadSP
CalculateThread()1693 Target::CalculateThread ()
1694 {
1695 return ThreadSP();
1696 }
1697
1698 StackFrameSP
CalculateStackFrame()1699 Target::CalculateStackFrame ()
1700 {
1701 return StackFrameSP();
1702 }
1703
1704 void
CalculateExecutionContext(ExecutionContext & exe_ctx)1705 Target::CalculateExecutionContext (ExecutionContext &exe_ctx)
1706 {
1707 exe_ctx.Clear();
1708 exe_ctx.SetTargetPtr(this);
1709 }
1710
1711 PathMappingList &
GetImageSearchPathList()1712 Target::GetImageSearchPathList ()
1713 {
1714 return m_image_search_paths;
1715 }
1716
1717 void
ImageSearchPathsChanged(const PathMappingList & path_list,void * baton)1718 Target::ImageSearchPathsChanged
1719 (
1720 const PathMappingList &path_list,
1721 void *baton
1722 )
1723 {
1724 Target *target = (Target *)baton;
1725 ModuleSP exe_module_sp (target->GetExecutableModule());
1726 if (exe_module_sp)
1727 {
1728 target->m_images.Clear();
1729 target->SetExecutableModule (exe_module_sp, true);
1730 }
1731 }
1732
1733 ClangASTContext *
GetScratchClangASTContext(bool create_on_demand)1734 Target::GetScratchClangASTContext(bool create_on_demand)
1735 {
1736 // Now see if we know the target triple, and if so, create our scratch AST context:
1737 if (m_scratch_ast_context_ap.get() == NULL && m_arch.IsValid() && create_on_demand)
1738 {
1739 m_scratch_ast_context_ap.reset (new ClangASTContext(m_arch.GetTriple().str().c_str()));
1740 m_scratch_ast_source_ap.reset (new ClangASTSource(shared_from_this()));
1741 m_scratch_ast_source_ap->InstallASTContext(m_scratch_ast_context_ap->getASTContext());
1742 llvm::OwningPtr<clang::ExternalASTSource> proxy_ast_source(m_scratch_ast_source_ap->CreateProxy());
1743 m_scratch_ast_context_ap->SetExternalSource(proxy_ast_source);
1744 }
1745 return m_scratch_ast_context_ap.get();
1746 }
1747
1748 ClangASTImporter *
GetClangASTImporter()1749 Target::GetClangASTImporter()
1750 {
1751 ClangASTImporter *ast_importer = m_ast_importer_ap.get();
1752
1753 if (!ast_importer)
1754 {
1755 ast_importer = new ClangASTImporter();
1756 m_ast_importer_ap.reset(ast_importer);
1757 }
1758
1759 return ast_importer;
1760 }
1761
1762 void
SettingsInitialize()1763 Target::SettingsInitialize ()
1764 {
1765 Process::SettingsInitialize ();
1766 }
1767
1768 void
SettingsTerminate()1769 Target::SettingsTerminate ()
1770 {
1771 Process::SettingsTerminate ();
1772 }
1773
1774 FileSpecList
GetDefaultExecutableSearchPaths()1775 Target::GetDefaultExecutableSearchPaths ()
1776 {
1777 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
1778 if (properties_sp)
1779 return properties_sp->GetExecutableSearchPaths();
1780 return FileSpecList();
1781 }
1782
1783 FileSpecList
GetDefaultDebugFileSearchPaths()1784 Target::GetDefaultDebugFileSearchPaths ()
1785 {
1786 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
1787 if (properties_sp)
1788 return properties_sp->GetDebugFileSearchPaths();
1789 return FileSpecList();
1790 }
1791
1792 ArchSpec
GetDefaultArchitecture()1793 Target::GetDefaultArchitecture ()
1794 {
1795 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
1796 if (properties_sp)
1797 return properties_sp->GetDefaultArchitecture();
1798 return ArchSpec();
1799 }
1800
1801 void
SetDefaultArchitecture(const ArchSpec & arch)1802 Target::SetDefaultArchitecture (const ArchSpec &arch)
1803 {
1804 TargetPropertiesSP properties_sp(Target::GetGlobalProperties());
1805 if (properties_sp)
1806 {
1807 LogIfAnyCategoriesSet(LIBLLDB_LOG_TARGET, "Target::SetDefaultArchitecture setting target's default architecture to %s (%s)", arch.GetArchitectureName(), arch.GetTriple().getTriple().c_str());
1808 return properties_sp->SetDefaultArchitecture(arch);
1809 }
1810 }
1811
1812 Target *
GetTargetFromContexts(const ExecutionContext * exe_ctx_ptr,const SymbolContext * sc_ptr)1813 Target::GetTargetFromContexts (const ExecutionContext *exe_ctx_ptr, const SymbolContext *sc_ptr)
1814 {
1815 // The target can either exist in the "process" of ExecutionContext, or in
1816 // the "target_sp" member of SymbolContext. This accessor helper function
1817 // will get the target from one of these locations.
1818
1819 Target *target = NULL;
1820 if (sc_ptr != NULL)
1821 target = sc_ptr->target_sp.get();
1822 if (target == NULL && exe_ctx_ptr)
1823 target = exe_ctx_ptr->GetTargetPtr();
1824 return target;
1825 }
1826
1827 ExecutionResults
EvaluateExpression(const char * expr_cstr,StackFrame * frame,lldb::ValueObjectSP & result_valobj_sp,const EvaluateExpressionOptions & options)1828 Target::EvaluateExpression
1829 (
1830 const char *expr_cstr,
1831 StackFrame *frame,
1832 lldb::ValueObjectSP &result_valobj_sp,
1833 const EvaluateExpressionOptions& options
1834 )
1835 {
1836 result_valobj_sp.reset();
1837
1838 ExecutionResults execution_results = eExecutionSetupError;
1839
1840 if (expr_cstr == NULL || expr_cstr[0] == '\0')
1841 return execution_results;
1842
1843 // We shouldn't run stop hooks in expressions.
1844 // Be sure to reset this if you return anywhere within this function.
1845 bool old_suppress_value = m_suppress_stop_hooks;
1846 m_suppress_stop_hooks = true;
1847
1848 ExecutionContext exe_ctx;
1849
1850 if (frame)
1851 {
1852 frame->CalculateExecutionContext(exe_ctx);
1853 }
1854 else if (m_process_sp)
1855 {
1856 m_process_sp->CalculateExecutionContext(exe_ctx);
1857 }
1858 else
1859 {
1860 CalculateExecutionContext(exe_ctx);
1861 }
1862
1863 // Make sure we aren't just trying to see the value of a persistent
1864 // variable (something like "$0")
1865 lldb::ClangExpressionVariableSP persistent_var_sp;
1866 // Only check for persistent variables the expression starts with a '$'
1867 if (expr_cstr[0] == '$')
1868 persistent_var_sp = m_persistent_variables.GetVariable (expr_cstr);
1869
1870 if (persistent_var_sp)
1871 {
1872 result_valobj_sp = persistent_var_sp->GetValueObject ();
1873 execution_results = eExecutionCompleted;
1874 }
1875 else
1876 {
1877 const char *prefix = GetExpressionPrefixContentsAsCString();
1878
1879 execution_results = ClangUserExpression::Evaluate (exe_ctx,
1880 options.GetExecutionPolicy(),
1881 lldb::eLanguageTypeUnknown,
1882 options.DoesCoerceToId() ? ClangUserExpression::eResultTypeId : ClangUserExpression::eResultTypeAny,
1883 options.DoesUnwindOnError(),
1884 options.DoesIgnoreBreakpoints(),
1885 expr_cstr,
1886 prefix,
1887 result_valobj_sp,
1888 options.GetRunOthers(),
1889 options.GetTimeoutUsec());
1890 }
1891
1892 m_suppress_stop_hooks = old_suppress_value;
1893
1894 return execution_results;
1895 }
1896
1897 lldb::addr_t
GetCallableLoadAddress(lldb::addr_t load_addr,AddressClass addr_class) const1898 Target::GetCallableLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
1899 {
1900 addr_t code_addr = load_addr;
1901 switch (m_arch.GetMachine())
1902 {
1903 case llvm::Triple::arm:
1904 case llvm::Triple::thumb:
1905 switch (addr_class)
1906 {
1907 case eAddressClassData:
1908 case eAddressClassDebug:
1909 return LLDB_INVALID_ADDRESS;
1910
1911 case eAddressClassUnknown:
1912 case eAddressClassInvalid:
1913 case eAddressClassCode:
1914 case eAddressClassCodeAlternateISA:
1915 case eAddressClassRuntime:
1916 // Check if bit zero it no set?
1917 if ((code_addr & 1ull) == 0)
1918 {
1919 // Bit zero isn't set, check if the address is a multiple of 2?
1920 if (code_addr & 2ull)
1921 {
1922 // The address is a multiple of 2 so it must be thumb, set bit zero
1923 code_addr |= 1ull;
1924 }
1925 else if (addr_class == eAddressClassCodeAlternateISA)
1926 {
1927 // We checked the address and the address claims to be the alternate ISA
1928 // which means thumb, so set bit zero.
1929 code_addr |= 1ull;
1930 }
1931 }
1932 break;
1933 }
1934 break;
1935
1936 default:
1937 break;
1938 }
1939 return code_addr;
1940 }
1941
1942 lldb::addr_t
GetOpcodeLoadAddress(lldb::addr_t load_addr,AddressClass addr_class) const1943 Target::GetOpcodeLoadAddress (lldb::addr_t load_addr, AddressClass addr_class) const
1944 {
1945 addr_t opcode_addr = load_addr;
1946 switch (m_arch.GetMachine())
1947 {
1948 case llvm::Triple::arm:
1949 case llvm::Triple::thumb:
1950 switch (addr_class)
1951 {
1952 case eAddressClassData:
1953 case eAddressClassDebug:
1954 return LLDB_INVALID_ADDRESS;
1955
1956 case eAddressClassInvalid:
1957 case eAddressClassUnknown:
1958 case eAddressClassCode:
1959 case eAddressClassCodeAlternateISA:
1960 case eAddressClassRuntime:
1961 opcode_addr &= ~(1ull);
1962 break;
1963 }
1964 break;
1965
1966 default:
1967 break;
1968 }
1969 return opcode_addr;
1970 }
1971
1972 SourceManager &
GetSourceManager()1973 Target::GetSourceManager ()
1974 {
1975 if (m_source_manager_ap.get() == NULL)
1976 m_source_manager_ap.reset (new SourceManager(shared_from_this()));
1977 return *m_source_manager_ap;
1978 }
1979
1980
1981 lldb::user_id_t
AddStopHook(Target::StopHookSP & new_hook_sp)1982 Target::AddStopHook (Target::StopHookSP &new_hook_sp)
1983 {
1984 lldb::user_id_t new_uid = ++m_stop_hook_next_id;
1985 new_hook_sp.reset (new StopHook(shared_from_this(), new_uid));
1986 m_stop_hooks[new_uid] = new_hook_sp;
1987 return new_uid;
1988 }
1989
1990 bool
RemoveStopHookByID(lldb::user_id_t user_id)1991 Target::RemoveStopHookByID (lldb::user_id_t user_id)
1992 {
1993 size_t num_removed;
1994 num_removed = m_stop_hooks.erase (user_id);
1995 if (num_removed == 0)
1996 return false;
1997 else
1998 return true;
1999 }
2000
2001 void
RemoveAllStopHooks()2002 Target::RemoveAllStopHooks ()
2003 {
2004 m_stop_hooks.clear();
2005 }
2006
2007 Target::StopHookSP
GetStopHookByID(lldb::user_id_t user_id)2008 Target::GetStopHookByID (lldb::user_id_t user_id)
2009 {
2010 StopHookSP found_hook;
2011
2012 StopHookCollection::iterator specified_hook_iter;
2013 specified_hook_iter = m_stop_hooks.find (user_id);
2014 if (specified_hook_iter != m_stop_hooks.end())
2015 found_hook = (*specified_hook_iter).second;
2016 return found_hook;
2017 }
2018
2019 bool
SetStopHookActiveStateByID(lldb::user_id_t user_id,bool active_state)2020 Target::SetStopHookActiveStateByID (lldb::user_id_t user_id, bool active_state)
2021 {
2022 StopHookCollection::iterator specified_hook_iter;
2023 specified_hook_iter = m_stop_hooks.find (user_id);
2024 if (specified_hook_iter == m_stop_hooks.end())
2025 return false;
2026
2027 (*specified_hook_iter).second->SetIsActive (active_state);
2028 return true;
2029 }
2030
2031 void
SetAllStopHooksActiveState(bool active_state)2032 Target::SetAllStopHooksActiveState (bool active_state)
2033 {
2034 StopHookCollection::iterator pos, end = m_stop_hooks.end();
2035 for (pos = m_stop_hooks.begin(); pos != end; pos++)
2036 {
2037 (*pos).second->SetIsActive (active_state);
2038 }
2039 }
2040
2041 void
RunStopHooks()2042 Target::RunStopHooks ()
2043 {
2044 if (m_suppress_stop_hooks)
2045 return;
2046
2047 if (!m_process_sp)
2048 return;
2049
2050 // <rdar://problem/12027563> make sure we check that we are not stopped because of us running a user expression
2051 // since in that case we do not want to run the stop-hooks
2052 if (m_process_sp->GetModIDRef().IsLastResumeForUserExpression())
2053 return;
2054
2055 if (m_stop_hooks.empty())
2056 return;
2057
2058 StopHookCollection::iterator pos, end = m_stop_hooks.end();
2059
2060 // If there aren't any active stop hooks, don't bother either:
2061 bool any_active_hooks = false;
2062 for (pos = m_stop_hooks.begin(); pos != end; pos++)
2063 {
2064 if ((*pos).second->IsActive())
2065 {
2066 any_active_hooks = true;
2067 break;
2068 }
2069 }
2070 if (!any_active_hooks)
2071 return;
2072
2073 CommandReturnObject result;
2074
2075 std::vector<ExecutionContext> exc_ctx_with_reasons;
2076 std::vector<SymbolContext> sym_ctx_with_reasons;
2077
2078 ThreadList &cur_threadlist = m_process_sp->GetThreadList();
2079 size_t num_threads = cur_threadlist.GetSize();
2080 for (size_t i = 0; i < num_threads; i++)
2081 {
2082 lldb::ThreadSP cur_thread_sp = cur_threadlist.GetThreadAtIndex (i);
2083 if (cur_thread_sp->ThreadStoppedForAReason())
2084 {
2085 lldb::StackFrameSP cur_frame_sp = cur_thread_sp->GetStackFrameAtIndex(0);
2086 exc_ctx_with_reasons.push_back(ExecutionContext(m_process_sp.get(), cur_thread_sp.get(), cur_frame_sp.get()));
2087 sym_ctx_with_reasons.push_back(cur_frame_sp->GetSymbolContext(eSymbolContextEverything));
2088 }
2089 }
2090
2091 // If no threads stopped for a reason, don't run the stop-hooks.
2092 size_t num_exe_ctx = exc_ctx_with_reasons.size();
2093 if (num_exe_ctx == 0)
2094 return;
2095
2096 result.SetImmediateOutputStream (m_debugger.GetAsyncOutputStream());
2097 result.SetImmediateErrorStream (m_debugger.GetAsyncErrorStream());
2098
2099 bool keep_going = true;
2100 bool hooks_ran = false;
2101 bool print_hook_header;
2102 bool print_thread_header;
2103
2104 if (num_exe_ctx == 1)
2105 print_thread_header = false;
2106 else
2107 print_thread_header = true;
2108
2109 if (m_stop_hooks.size() == 1)
2110 print_hook_header = false;
2111 else
2112 print_hook_header = true;
2113
2114 for (pos = m_stop_hooks.begin(); keep_going && pos != end; pos++)
2115 {
2116 // result.Clear();
2117 StopHookSP cur_hook_sp = (*pos).second;
2118 if (!cur_hook_sp->IsActive())
2119 continue;
2120
2121 bool any_thread_matched = false;
2122 for (size_t i = 0; keep_going && i < num_exe_ctx; i++)
2123 {
2124 if ((cur_hook_sp->GetSpecifier () == NULL
2125 || cur_hook_sp->GetSpecifier()->SymbolContextMatches(sym_ctx_with_reasons[i]))
2126 && (cur_hook_sp->GetThreadSpecifier() == NULL
2127 || cur_hook_sp->GetThreadSpecifier()->ThreadPassesBasicTests(exc_ctx_with_reasons[i].GetThreadRef())))
2128 {
2129 if (!hooks_ran)
2130 {
2131 hooks_ran = true;
2132 }
2133 if (print_hook_header && !any_thread_matched)
2134 {
2135 const char *cmd = (cur_hook_sp->GetCommands().GetSize() == 1 ?
2136 cur_hook_sp->GetCommands().GetStringAtIndex(0) :
2137 NULL);
2138 if (cmd)
2139 result.AppendMessageWithFormat("\n- Hook %" PRIu64 " (%s)\n", cur_hook_sp->GetID(), cmd);
2140 else
2141 result.AppendMessageWithFormat("\n- Hook %" PRIu64 "\n", cur_hook_sp->GetID());
2142 any_thread_matched = true;
2143 }
2144
2145 if (print_thread_header)
2146 result.AppendMessageWithFormat("-- Thread %d\n", exc_ctx_with_reasons[i].GetThreadPtr()->GetIndexID());
2147
2148 bool stop_on_continue = true;
2149 bool stop_on_error = true;
2150 bool echo_commands = false;
2151 bool print_results = true;
2152 GetDebugger().GetCommandInterpreter().HandleCommands (cur_hook_sp->GetCommands(),
2153 &exc_ctx_with_reasons[i],
2154 stop_on_continue,
2155 stop_on_error,
2156 echo_commands,
2157 print_results,
2158 eLazyBoolNo,
2159 result);
2160
2161 // If the command started the target going again, we should bag out of
2162 // running the stop hooks.
2163 if ((result.GetStatus() == eReturnStatusSuccessContinuingNoResult) ||
2164 (result.GetStatus() == eReturnStatusSuccessContinuingResult))
2165 {
2166 result.AppendMessageWithFormat ("Aborting stop hooks, hook %" PRIu64 " set the program running.", cur_hook_sp->GetID());
2167 keep_going = false;
2168 }
2169 }
2170 }
2171 }
2172
2173 result.GetImmediateOutputStream()->Flush();
2174 result.GetImmediateErrorStream()->Flush();
2175 }
2176
2177
2178 //--------------------------------------------------------------
2179 // class Target::StopHook
2180 //--------------------------------------------------------------
2181
2182
StopHook(lldb::TargetSP target_sp,lldb::user_id_t uid)2183 Target::StopHook::StopHook (lldb::TargetSP target_sp, lldb::user_id_t uid) :
2184 UserID (uid),
2185 m_target_sp (target_sp),
2186 m_commands (),
2187 m_specifier_sp (),
2188 m_thread_spec_ap(),
2189 m_active (true)
2190 {
2191 }
2192
StopHook(const StopHook & rhs)2193 Target::StopHook::StopHook (const StopHook &rhs) :
2194 UserID (rhs.GetID()),
2195 m_target_sp (rhs.m_target_sp),
2196 m_commands (rhs.m_commands),
2197 m_specifier_sp (rhs.m_specifier_sp),
2198 m_thread_spec_ap (),
2199 m_active (rhs.m_active)
2200 {
2201 if (rhs.m_thread_spec_ap.get() != NULL)
2202 m_thread_spec_ap.reset (new ThreadSpec(*rhs.m_thread_spec_ap.get()));
2203 }
2204
2205
~StopHook()2206 Target::StopHook::~StopHook ()
2207 {
2208 }
2209
2210 void
SetThreadSpecifier(ThreadSpec * specifier)2211 Target::StopHook::SetThreadSpecifier (ThreadSpec *specifier)
2212 {
2213 m_thread_spec_ap.reset (specifier);
2214 }
2215
2216
2217 void
GetDescription(Stream * s,lldb::DescriptionLevel level) const2218 Target::StopHook::GetDescription (Stream *s, lldb::DescriptionLevel level) const
2219 {
2220 int indent_level = s->GetIndentLevel();
2221
2222 s->SetIndentLevel(indent_level + 2);
2223
2224 s->Printf ("Hook: %" PRIu64 "\n", GetID());
2225 if (m_active)
2226 s->Indent ("State: enabled\n");
2227 else
2228 s->Indent ("State: disabled\n");
2229
2230 if (m_specifier_sp)
2231 {
2232 s->Indent();
2233 s->PutCString ("Specifier:\n");
2234 s->SetIndentLevel (indent_level + 4);
2235 m_specifier_sp->GetDescription (s, level);
2236 s->SetIndentLevel (indent_level + 2);
2237 }
2238
2239 if (m_thread_spec_ap.get() != NULL)
2240 {
2241 StreamString tmp;
2242 s->Indent("Thread:\n");
2243 m_thread_spec_ap->GetDescription (&tmp, level);
2244 s->SetIndentLevel (indent_level + 4);
2245 s->Indent (tmp.GetData());
2246 s->PutCString ("\n");
2247 s->SetIndentLevel (indent_level + 2);
2248 }
2249
2250 s->Indent ("Commands: \n");
2251 s->SetIndentLevel (indent_level + 4);
2252 uint32_t num_commands = m_commands.GetSize();
2253 for (uint32_t i = 0; i < num_commands; i++)
2254 {
2255 s->Indent(m_commands.GetStringAtIndex(i));
2256 s->PutCString ("\n");
2257 }
2258 s->SetIndentLevel (indent_level);
2259 }
2260
2261 //--------------------------------------------------------------
2262 // class TargetProperties
2263 //--------------------------------------------------------------
2264
2265 OptionEnumValueElement
2266 lldb_private::g_dynamic_value_types[] =
2267 {
2268 { eNoDynamicValues, "no-dynamic-values", "Don't calculate the dynamic type of values"},
2269 { eDynamicCanRunTarget, "run-target", "Calculate the dynamic type of values even if you have to run the target."},
2270 { eDynamicDontRunTarget, "no-run-target", "Calculate the dynamic type of values, but don't run the target."},
2271 { 0, NULL, NULL }
2272 };
2273
2274 static OptionEnumValueElement
2275 g_inline_breakpoint_enums[] =
2276 {
2277 { eInlineBreakpointsNever, "never", "Never look for inline breakpoint locations (fastest). This setting should only be used if you know that no inlining occurs in your programs."},
2278 { eInlineBreakpointsHeaders, "headers", "Only check for inline breakpoint locations when setting breakpoints in header files, but not when setting breakpoint in implementation source files (default)."},
2279 { eInlineBreakpointsAlways, "always", "Always look for inline breakpoint locations when setting file and line breakpoints (slower but most accurate)."},
2280 { 0, NULL, NULL }
2281 };
2282
2283 typedef enum x86DisassemblyFlavor
2284 {
2285 eX86DisFlavorDefault,
2286 eX86DisFlavorIntel,
2287 eX86DisFlavorATT
2288 } x86DisassemblyFlavor;
2289
2290 static OptionEnumValueElement
2291 g_x86_dis_flavor_value_types[] =
2292 {
2293 { eX86DisFlavorDefault, "default", "Disassembler default (currently att)."},
2294 { eX86DisFlavorIntel, "intel", "Intel disassembler flavor."},
2295 { eX86DisFlavorATT, "att", "AT&T disassembler flavor."},
2296 { 0, NULL, NULL }
2297 };
2298
2299 static OptionEnumValueElement
2300 g_hex_immediate_style_values[] =
2301 {
2302 { Disassembler::eHexStyleC, "c", "C-style (0xffff)."},
2303 { Disassembler::eHexStyleAsm, "asm", "Asm-style (0ffffh)."},
2304 { 0, NULL, NULL }
2305 };
2306
2307 static OptionEnumValueElement
2308 g_load_script_from_sym_file_values[] =
2309 {
2310 { eLoadScriptFromSymFileTrue, "true", "Load debug scripts inside symbol files"},
2311 { eLoadScriptFromSymFileFalse, "false", "Do not load debug scripts inside symbol files."},
2312 { eLoadScriptFromSymFileWarn, "warn", "Warn about debug scripts inside symbol files but do not load them."},
2313 { 0, NULL, NULL }
2314 };
2315
2316 static PropertyDefinition
2317 g_properties[] =
2318 {
2319 { "default-arch" , OptionValue::eTypeArch , true , 0 , NULL, NULL, "Default architecture to choose, when there's a choice." },
2320 { "expr-prefix" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "Path to a file containing expressions to be prepended to all expressions." },
2321 { "prefer-dynamic-value" , OptionValue::eTypeEnum , false, eNoDynamicValues , NULL, g_dynamic_value_types, "Should printed values be shown as their dynamic value." },
2322 { "enable-synthetic-value" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Should synthetic values be used by default whenever available." },
2323 { "skip-prologue" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Skip function prologues when setting breakpoints by name." },
2324 { "source-map" , OptionValue::eTypePathMap , false, 0 , NULL, NULL, "Source path remappings used to track the change of location between a source file when built, and "
2325 "where it exists on the current system. It consists of an array of duples, the first element of each duple is "
2326 "some part (starting at the root) of the path to the file when it was built, "
2327 "and the second is where the remainder of the original build hierarchy is rooted on the local system. "
2328 "Each element of the array is checked in order and the first one that results in a match wins." },
2329 { "exec-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "Executable search paths to use when locating executable files whose paths don't match the local file system." },
2330 { "debug-file-search-paths" , OptionValue::eTypeFileSpecList, false, 0 , NULL, NULL, "List of directories to be searched when locating debug symbol files." },
2331 { "max-children-count" , OptionValue::eTypeSInt64 , false, 256 , NULL, NULL, "Maximum number of children to expand in any level of depth." },
2332 { "max-string-summary-length" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of characters to show when using %s in summary strings." },
2333 { "max-memory-read-size" , OptionValue::eTypeSInt64 , false, 1024 , NULL, NULL, "Maximum number of bytes that 'memory read' will fetch before --force must be specified." },
2334 { "breakpoints-use-platform-avoid-list", OptionValue::eTypeBoolean , false, true , NULL, NULL, "Consult the platform module avoid list when setting non-module specific breakpoints." },
2335 { "arg0" , OptionValue::eTypeString , false, 0 , NULL, NULL, "The first argument passed to the program in the argument array which can be different from the executable itself." },
2336 { "run-args" , OptionValue::eTypeArgs , false, 0 , NULL, NULL, "A list containing all the arguments to be passed to the executable when it is run. Note that this does NOT include the argv[0] which is in target.arg0." },
2337 { "env-vars" , OptionValue::eTypeDictionary, false, OptionValue::eTypeString , NULL, NULL, "A list of all the environment variables to be passed to the executable's environment, and their values." },
2338 { "inherit-env" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Inherit the environment from the process that is running LLDB." },
2339 { "input-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for reading its standard input." },
2340 { "output-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard output." },
2341 { "error-path" , OptionValue::eTypeFileSpec , false, 0 , NULL, NULL, "The file/path to be used by the executable program for writing its standard error." },
2342 { "disable-aslr" , OptionValue::eTypeBoolean , false, true , NULL, NULL, "Disable Address Space Layout Randomization (ASLR)" },
2343 { "disable-stdio" , OptionValue::eTypeBoolean , false, false , NULL, NULL, "Disable stdin/stdout for process (e.g. for a GUI application)" },
2344 { "inline-breakpoint-strategy" , OptionValue::eTypeEnum , false, eInlineBreakpointsHeaders , NULL, g_inline_breakpoint_enums, "The strategy to use when settings breakpoints by file and line. "
2345 "Breakpoint locations can end up being inlined by the compiler, so that a compile unit 'a.c' might contain an inlined function from another source file. "
2346 "Usually this is limitted to breakpoint locations from inlined functions from header or other include files, or more accurately non-implementation source files. "
2347 "Sometimes code might #include implementation files and cause inlined breakpoint locations in inlined implementation files. "
2348 "Always checking for inlined breakpoint locations can be expensive (memory and time), so we try to minimize the "
2349 "times we look for inlined locations. This setting allows you to control exactly which strategy is used when settings "
2350 "file and line breakpoints." },
2351 // FIXME: This is the wrong way to do per-architecture settings, but we don't have a general per architecture settings system in place yet.
2352 { "x86-disassembly-flavor" , OptionValue::eTypeEnum , false, eX86DisFlavorDefault, NULL, g_x86_dis_flavor_value_types, "The default disassembly flavor to use for x86 or x86-64 targets." },
2353 { "use-hex-immediates" , OptionValue::eTypeBoolean , false, true, NULL, NULL, "Show immediates in disassembly as hexadecimal." },
2354 { "hex-immediate-style" , OptionValue::eTypeEnum , false, Disassembler::eHexStyleC, NULL, g_hex_immediate_style_values, "Which style to use for printing hexadecimal disassembly values." },
2355 { "use-fast-stepping" , OptionValue::eTypeBoolean , false, true, NULL, NULL, "Use a fast stepping algorithm based on running from branch to branch rather than instruction single-stepping." },
2356 { "load-script-from-symbol-file" , OptionValue::eTypeEnum , false, eLoadScriptFromSymFileWarn, NULL, g_load_script_from_sym_file_values, "Allow LLDB to load scripting resources embedded in symbol files when available." },
2357 { NULL , OptionValue::eTypeInvalid , false, 0 , NULL, NULL, NULL }
2358 };
2359 enum
2360 {
2361 ePropertyDefaultArch,
2362 ePropertyExprPrefix,
2363 ePropertyPreferDynamic,
2364 ePropertyEnableSynthetic,
2365 ePropertySkipPrologue,
2366 ePropertySourceMap,
2367 ePropertyExecutableSearchPaths,
2368 ePropertyDebugFileSearchPaths,
2369 ePropertyMaxChildrenCount,
2370 ePropertyMaxSummaryLength,
2371 ePropertyMaxMemReadSize,
2372 ePropertyBreakpointUseAvoidList,
2373 ePropertyArg0,
2374 ePropertyRunArgs,
2375 ePropertyEnvVars,
2376 ePropertyInheritEnv,
2377 ePropertyInputPath,
2378 ePropertyOutputPath,
2379 ePropertyErrorPath,
2380 ePropertyDisableASLR,
2381 ePropertyDisableSTDIO,
2382 ePropertyInlineStrategy,
2383 ePropertyDisassemblyFlavor,
2384 ePropertyUseHexImmediates,
2385 ePropertyHexImmediateStyle,
2386 ePropertyUseFastStepping,
2387 ePropertyLoadScriptFromSymbolFile,
2388 };
2389
2390
2391 class TargetOptionValueProperties : public OptionValueProperties
2392 {
2393 public:
TargetOptionValueProperties(const ConstString & name)2394 TargetOptionValueProperties (const ConstString &name) :
2395 OptionValueProperties (name),
2396 m_target (NULL),
2397 m_got_host_env (false)
2398 {
2399 }
2400
2401 // This constructor is used when creating TargetOptionValueProperties when it
2402 // is part of a new lldb_private::Target instance. It will copy all current
2403 // global property values as needed
TargetOptionValueProperties(Target * target,const TargetPropertiesSP & target_properties_sp)2404 TargetOptionValueProperties (Target *target, const TargetPropertiesSP &target_properties_sp) :
2405 OptionValueProperties(*target_properties_sp->GetValueProperties()),
2406 m_target (target),
2407 m_got_host_env (false)
2408 {
2409 }
2410
2411 virtual const Property *
GetPropertyAtIndex(const ExecutionContext * exe_ctx,bool will_modify,uint32_t idx) const2412 GetPropertyAtIndex (const ExecutionContext *exe_ctx, bool will_modify, uint32_t idx) const
2413 {
2414 // When gettings the value for a key from the target options, we will always
2415 // try and grab the setting from the current target if there is one. Else we just
2416 // use the one from this instance.
2417 if (idx == ePropertyEnvVars)
2418 GetHostEnvironmentIfNeeded ();
2419
2420 if (exe_ctx)
2421 {
2422 Target *target = exe_ctx->GetTargetPtr();
2423 if (target)
2424 {
2425 TargetOptionValueProperties *target_properties = static_cast<TargetOptionValueProperties *>(target->GetValueProperties().get());
2426 if (this != target_properties)
2427 return target_properties->ProtectedGetPropertyAtIndex (idx);
2428 }
2429 }
2430 return ProtectedGetPropertyAtIndex (idx);
2431 }
2432
2433 lldb::TargetSP
GetTargetSP()2434 GetTargetSP ()
2435 {
2436 return m_target->shared_from_this();
2437 }
2438
2439 protected:
2440
2441 void
GetHostEnvironmentIfNeeded() const2442 GetHostEnvironmentIfNeeded () const
2443 {
2444 if (!m_got_host_env)
2445 {
2446 if (m_target)
2447 {
2448 m_got_host_env = true;
2449 const uint32_t idx = ePropertyInheritEnv;
2450 if (GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0))
2451 {
2452 PlatformSP platform_sp (m_target->GetPlatform());
2453 if (platform_sp)
2454 {
2455 StringList env;
2456 if (platform_sp->GetEnvironment(env))
2457 {
2458 OptionValueDictionary *env_dict = GetPropertyAtIndexAsOptionValueDictionary (NULL, ePropertyEnvVars);
2459 if (env_dict)
2460 {
2461 const bool can_replace = false;
2462 const size_t envc = env.GetSize();
2463 for (size_t idx=0; idx<envc; idx++)
2464 {
2465 const char *env_entry = env.GetStringAtIndex (idx);
2466 if (env_entry)
2467 {
2468 const char *equal_pos = ::strchr(env_entry, '=');
2469 ConstString key;
2470 // It is ok to have environment variables with no values
2471 const char *value = NULL;
2472 if (equal_pos)
2473 {
2474 key.SetCStringWithLength(env_entry, equal_pos - env_entry);
2475 if (equal_pos[1])
2476 value = equal_pos + 1;
2477 }
2478 else
2479 {
2480 key.SetCString(env_entry);
2481 }
2482 // Don't allow existing keys to be replaced with ones we get from the platform environment
2483 env_dict->SetValueForKey(key, OptionValueSP(new OptionValueString(value)), can_replace);
2484 }
2485 }
2486 }
2487 }
2488 }
2489 }
2490 }
2491 }
2492 }
2493 Target *m_target;
2494 mutable bool m_got_host_env;
2495 };
2496
TargetProperties(Target * target)2497 TargetProperties::TargetProperties (Target *target) :
2498 Properties ()
2499 {
2500 if (target)
2501 {
2502 m_collection_sp.reset (new TargetOptionValueProperties(target, Target::GetGlobalProperties()));
2503 }
2504 else
2505 {
2506 m_collection_sp.reset (new TargetOptionValueProperties(ConstString("target")));
2507 m_collection_sp->Initialize(g_properties);
2508 m_collection_sp->AppendProperty(ConstString("process"),
2509 ConstString("Settings specify to processes."),
2510 true,
2511 Process::GetGlobalProperties()->GetValueProperties());
2512 }
2513 }
2514
~TargetProperties()2515 TargetProperties::~TargetProperties ()
2516 {
2517 }
2518 ArchSpec
GetDefaultArchitecture() const2519 TargetProperties::GetDefaultArchitecture () const
2520 {
2521 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch);
2522 if (value)
2523 return value->GetCurrentValue();
2524 return ArchSpec();
2525 }
2526
2527 void
SetDefaultArchitecture(const ArchSpec & arch)2528 TargetProperties::SetDefaultArchitecture (const ArchSpec& arch)
2529 {
2530 OptionValueArch *value = m_collection_sp->GetPropertyAtIndexAsOptionValueArch (NULL, ePropertyDefaultArch);
2531 if (value)
2532 return value->SetCurrentValue(arch, true);
2533 }
2534
2535 lldb::DynamicValueType
GetPreferDynamicValue() const2536 TargetProperties::GetPreferDynamicValue() const
2537 {
2538 const uint32_t idx = ePropertyPreferDynamic;
2539 return (lldb::DynamicValueType)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
2540 }
2541
2542 bool
GetDisableASLR() const2543 TargetProperties::GetDisableASLR () const
2544 {
2545 const uint32_t idx = ePropertyDisableASLR;
2546 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2547 }
2548
2549 void
SetDisableASLR(bool b)2550 TargetProperties::SetDisableASLR (bool b)
2551 {
2552 const uint32_t idx = ePropertyDisableASLR;
2553 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
2554 }
2555
2556 bool
GetDisableSTDIO() const2557 TargetProperties::GetDisableSTDIO () const
2558 {
2559 const uint32_t idx = ePropertyDisableSTDIO;
2560 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2561 }
2562
2563 void
SetDisableSTDIO(bool b)2564 TargetProperties::SetDisableSTDIO (bool b)
2565 {
2566 const uint32_t idx = ePropertyDisableSTDIO;
2567 m_collection_sp->SetPropertyAtIndexAsBoolean (NULL, idx, b);
2568 }
2569
2570 const char *
GetDisassemblyFlavor() const2571 TargetProperties::GetDisassemblyFlavor () const
2572 {
2573 const uint32_t idx = ePropertyDisassemblyFlavor;
2574 const char *return_value;
2575
2576 x86DisassemblyFlavor flavor_value = (x86DisassemblyFlavor) m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
2577 return_value = g_x86_dis_flavor_value_types[flavor_value].string_value;
2578 return return_value;
2579 }
2580
2581 InlineStrategy
GetInlineStrategy() const2582 TargetProperties::GetInlineStrategy () const
2583 {
2584 const uint32_t idx = ePropertyInlineStrategy;
2585 return (InlineStrategy)m_collection_sp->GetPropertyAtIndexAsEnumeration (NULL, idx, g_properties[idx].default_uint_value);
2586 }
2587
2588 const char *
GetArg0() const2589 TargetProperties::GetArg0 () const
2590 {
2591 const uint32_t idx = ePropertyArg0;
2592 return m_collection_sp->GetPropertyAtIndexAsString (NULL, idx, NULL);
2593 }
2594
2595 void
SetArg0(const char * arg)2596 TargetProperties::SetArg0 (const char *arg)
2597 {
2598 const uint32_t idx = ePropertyArg0;
2599 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, arg);
2600 }
2601
2602 bool
GetRunArguments(Args & args) const2603 TargetProperties::GetRunArguments (Args &args) const
2604 {
2605 const uint32_t idx = ePropertyRunArgs;
2606 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, args);
2607 }
2608
2609 void
SetRunArguments(const Args & args)2610 TargetProperties::SetRunArguments (const Args &args)
2611 {
2612 const uint32_t idx = ePropertyRunArgs;
2613 m_collection_sp->SetPropertyAtIndexFromArgs (NULL, idx, args);
2614 }
2615
2616 size_t
GetEnvironmentAsArgs(Args & env) const2617 TargetProperties::GetEnvironmentAsArgs (Args &env) const
2618 {
2619 const uint32_t idx = ePropertyEnvVars;
2620 return m_collection_sp->GetPropertyAtIndexAsArgs (NULL, idx, env);
2621 }
2622
2623 bool
GetSkipPrologue() const2624 TargetProperties::GetSkipPrologue() const
2625 {
2626 const uint32_t idx = ePropertySkipPrologue;
2627 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2628 }
2629
2630 PathMappingList &
GetSourcePathMap() const2631 TargetProperties::GetSourcePathMap () const
2632 {
2633 const uint32_t idx = ePropertySourceMap;
2634 OptionValuePathMappings *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValuePathMappings (NULL, false, idx);
2635 assert(option_value);
2636 return option_value->GetCurrentValue();
2637 }
2638
2639 FileSpecList &
GetExecutableSearchPaths()2640 TargetProperties::GetExecutableSearchPaths ()
2641 {
2642 const uint32_t idx = ePropertyExecutableSearchPaths;
2643 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx);
2644 assert(option_value);
2645 return option_value->GetCurrentValue();
2646 }
2647
2648 FileSpecList &
GetDebugFileSearchPaths()2649 TargetProperties::GetDebugFileSearchPaths ()
2650 {
2651 const uint32_t idx = ePropertyDebugFileSearchPaths;
2652 OptionValueFileSpecList *option_value = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpecList (NULL, false, idx);
2653 assert(option_value);
2654 return option_value->GetCurrentValue();
2655 }
2656
2657 bool
GetEnableSyntheticValue() const2658 TargetProperties::GetEnableSyntheticValue () const
2659 {
2660 const uint32_t idx = ePropertyEnableSynthetic;
2661 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2662 }
2663
2664 uint32_t
GetMaximumNumberOfChildrenToDisplay() const2665 TargetProperties::GetMaximumNumberOfChildrenToDisplay() const
2666 {
2667 const uint32_t idx = ePropertyMaxChildrenCount;
2668 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
2669 }
2670
2671 uint32_t
GetMaximumSizeOfStringSummary() const2672 TargetProperties::GetMaximumSizeOfStringSummary() const
2673 {
2674 const uint32_t idx = ePropertyMaxSummaryLength;
2675 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
2676 }
2677
2678 uint32_t
GetMaximumMemReadSize() const2679 TargetProperties::GetMaximumMemReadSize () const
2680 {
2681 const uint32_t idx = ePropertyMaxMemReadSize;
2682 return m_collection_sp->GetPropertyAtIndexAsSInt64 (NULL, idx, g_properties[idx].default_uint_value);
2683 }
2684
2685 FileSpec
GetStandardInputPath() const2686 TargetProperties::GetStandardInputPath () const
2687 {
2688 const uint32_t idx = ePropertyInputPath;
2689 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx);
2690 }
2691
2692 void
SetStandardInputPath(const char * p)2693 TargetProperties::SetStandardInputPath (const char *p)
2694 {
2695 const uint32_t idx = ePropertyInputPath;
2696 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
2697 }
2698
2699 FileSpec
GetStandardOutputPath() const2700 TargetProperties::GetStandardOutputPath () const
2701 {
2702 const uint32_t idx = ePropertyOutputPath;
2703 return m_collection_sp->GetPropertyAtIndexAsFileSpec (NULL, idx);
2704 }
2705
2706 void
SetStandardOutputPath(const char * p)2707 TargetProperties::SetStandardOutputPath (const char *p)
2708 {
2709 const uint32_t idx = ePropertyOutputPath;
2710 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
2711 }
2712
2713 FileSpec
GetStandardErrorPath() const2714 TargetProperties::GetStandardErrorPath () const
2715 {
2716 const uint32_t idx = ePropertyErrorPath;
2717 return m_collection_sp->GetPropertyAtIndexAsFileSpec(NULL, idx);
2718 }
2719
2720 const char *
GetExpressionPrefixContentsAsCString()2721 TargetProperties::GetExpressionPrefixContentsAsCString ()
2722 {
2723 const uint32_t idx = ePropertyExprPrefix;
2724 OptionValueFileSpec *file = m_collection_sp->GetPropertyAtIndexAsOptionValueFileSpec (NULL, false, idx);
2725 if (file)
2726 {
2727 const bool null_terminate = true;
2728 DataBufferSP data_sp(file->GetFileContents(null_terminate));
2729 if (data_sp)
2730 return (const char *) data_sp->GetBytes();
2731 }
2732 return NULL;
2733 }
2734
2735 void
SetStandardErrorPath(const char * p)2736 TargetProperties::SetStandardErrorPath (const char *p)
2737 {
2738 const uint32_t idx = ePropertyErrorPath;
2739 m_collection_sp->SetPropertyAtIndexAsString (NULL, idx, p);
2740 }
2741
2742 bool
GetBreakpointsConsultPlatformAvoidList()2743 TargetProperties::GetBreakpointsConsultPlatformAvoidList ()
2744 {
2745 const uint32_t idx = ePropertyBreakpointUseAvoidList;
2746 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2747 }
2748
2749 bool
GetUseHexImmediates() const2750 TargetProperties::GetUseHexImmediates () const
2751 {
2752 const uint32_t idx = ePropertyUseHexImmediates;
2753 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2754 }
2755
2756 bool
GetUseFastStepping() const2757 TargetProperties::GetUseFastStepping () const
2758 {
2759 const uint32_t idx = ePropertyUseFastStepping;
2760 return m_collection_sp->GetPropertyAtIndexAsBoolean (NULL, idx, g_properties[idx].default_uint_value != 0);
2761 }
2762
2763 LoadScriptFromSymFile
GetLoadScriptFromSymbolFile() const2764 TargetProperties::GetLoadScriptFromSymbolFile () const
2765 {
2766 const uint32_t idx = ePropertyLoadScriptFromSymbolFile;
2767 return (LoadScriptFromSymFile)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value);
2768 }
2769
2770 Disassembler::HexImmediateStyle
GetHexImmediateStyle() const2771 TargetProperties::GetHexImmediateStyle () const
2772 {
2773 const uint32_t idx = ePropertyHexImmediateStyle;
2774 return (Disassembler::HexImmediateStyle)m_collection_sp->GetPropertyAtIndexAsEnumeration(NULL, idx, g_properties[idx].default_uint_value);
2775 }
2776
2777 const TargetPropertiesSP &
GetGlobalProperties()2778 Target::GetGlobalProperties()
2779 {
2780 static TargetPropertiesSP g_settings_sp;
2781 if (!g_settings_sp)
2782 {
2783 g_settings_sp.reset (new TargetProperties (NULL));
2784 }
2785 return g_settings_sp;
2786 }
2787
2788 const ConstString &
GetFlavorString()2789 Target::TargetEventData::GetFlavorString ()
2790 {
2791 static ConstString g_flavor ("Target::TargetEventData");
2792 return g_flavor;
2793 }
2794
2795 const ConstString &
GetFlavor() const2796 Target::TargetEventData::GetFlavor () const
2797 {
2798 return TargetEventData::GetFlavorString ();
2799 }
2800
TargetEventData(const lldb::TargetSP & new_target_sp)2801 Target::TargetEventData::TargetEventData (const lldb::TargetSP &new_target_sp) :
2802 EventData(),
2803 m_target_sp (new_target_sp)
2804 {
2805 }
2806
~TargetEventData()2807 Target::TargetEventData::~TargetEventData()
2808 {
2809
2810 }
2811
2812 void
Dump(Stream * s) const2813 Target::TargetEventData::Dump (Stream *s) const
2814 {
2815
2816 }
2817
2818 const TargetSP
GetTargetFromEvent(const lldb::EventSP & event_sp)2819 Target::TargetEventData::GetTargetFromEvent (const lldb::EventSP &event_sp)
2820 {
2821 TargetSP target_sp;
2822
2823 const TargetEventData *data = GetEventDataFromEvent (event_sp.get());
2824 if (data)
2825 target_sp = data->m_target_sp;
2826
2827 return target_sp;
2828 }
2829
2830 const Target::TargetEventData *
GetEventDataFromEvent(const Event * event_ptr)2831 Target::TargetEventData::GetEventDataFromEvent (const Event *event_ptr)
2832 {
2833 if (event_ptr)
2834 {
2835 const EventData *event_data = event_ptr->GetData();
2836 if (event_data && event_data->GetFlavor() == TargetEventData::GetFlavorString())
2837 return static_cast <const TargetEventData *> (event_ptr->GetData());
2838 }
2839 return NULL;
2840 }
2841
2842