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