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