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