source/Breakpoint/BreakpointResolverAddress.cpp

   1 //===-- BreakpointResolverAddress.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/Breakpoint/BreakpointResolverAddress.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project includes
  16
  17 #include "lldb/Breakpoint/BreakpointLocation.h"
  18 #include "lldb/Core/Log.h"
  19 #include "lldb/Core/Module.h"
  20 #include "lldb/Core/StreamString.h"
  21 #include "lldb/Target/Process.h"
  22 #include "lldb/Target/Target.h"
  23
  24 using namespace lldb;
  25 using namespace lldb_private;
  26
  27 //----------------------------------------------------------------------
  28 // BreakpointResolverAddress:
  29 //----------------------------------------------------------------------
  30 BreakpointResolverAddress::BreakpointResolverAddress
  31 (
  32     Breakpoint *bkpt,
  33     const Address &addr,
  34     const FileSpec &module_spec
  35 ) :
  36     BreakpointResolver (bkpt, BreakpointResolver::AddressResolver),
  37     m_addr (addr),
  38     m_resolved_addr(LLDB_INVALID_ADDRESS),
  39     m_module_filespec(module_spec)
  40 {
  41 }
  42
  43 BreakpointResolverAddress::BreakpointResolverAddress
  44 (
  45     Breakpoint *bkpt,
  46     const Address &addr
  47 ) :
  48     BreakpointResolver (bkpt, BreakpointResolver::AddressResolver),
  49     m_addr (addr),
  50     m_resolved_addr(LLDB_INVALID_ADDRESS),
  51     m_module_filespec()
  52 {
  53 }
  54
  55 BreakpointResolverAddress::~BreakpointResolverAddress ()
  56 {
  57
  58 }
  59
  60 void
  61 BreakpointResolverAddress::ResolveBreakpoint (SearchFilter &filter)
  62 {
  63     // If the address is not section relative, then we should not try to re-resolve it, it is just some
  64     // random address and we wouldn't know what to do on reload.  But if it is section relative, we need to
  65     // re-resolve it since the section it's in may have shifted on re-run.
  66     bool re_resolve = false;
  67     if (m_addr.GetSection() || m_module_filespec)
  68         re_resolve = true;
  69     else if (m_breakpoint->GetNumLocations() == 0)
  70         re_resolve = true;
  71
  72     if (re_resolve)
  73         BreakpointResolver::ResolveBreakpoint(filter);
  74 }
  75
  76 void
  77 BreakpointResolverAddress::ResolveBreakpointInModules
  78 (
  79     SearchFilter &filter,
  80     ModuleList &modules
  81 )
  82 {
  83     // See comment in ResolveBreakpoint.
  84     bool re_resolve = false;
  85     if (m_addr.GetSection())
  86         re_resolve = true;
  87     else if (m_breakpoint->GetNumLocations() == 0)
  88         re_resolve = true;
  89
  90     if (re_resolve)
  91         BreakpointResolver::ResolveBreakpointInModules (filter, modules);
  92 }
  93
  94 Searcher::CallbackReturn
  95 BreakpointResolverAddress::SearchCallback
  96 (
  97     SearchFilter &filter,
  98     SymbolContext &context,
  99     Address *addr,
 100     bool containing
 101 )
 102 {
 103     assert (m_breakpoint != NULL);
 104
 105     if (filter.AddressPasses (m_addr))
 106     {
 107         if (m_breakpoint->GetNumLocations() == 0)
 108         {
 109             // If the address is just an offset, and we're given a module, see if we can find the appropriate module
 110             // loaded in the binary, and fix up m_addr to use that.
 111             if (!m_addr.IsSectionOffset() && m_module_filespec)
 112             {
 113                 Target &target = m_breakpoint->GetTarget();
 114                 ModuleSpec module_spec(m_module_filespec);
 115                 ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec);
 116                 if (module_sp)
 117                 {
 118                     Address tmp_address;
 119                     if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address))
 120                         m_addr = tmp_address;
 121                 }
 122             }
 123
 124             m_resolved_addr = m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
 125             BreakpointLocationSP bp_loc_sp(AddLocation(m_addr));
 126             if (bp_loc_sp && !m_breakpoint->IsInternal())
 127             {
 128                     StreamString s;
 129                     bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 130                     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
 131                     if (log)
 132                         log->Printf ("Added location: %s\n", s.GetData());
 133             }
 134         }
 135         else
 136         {
 137             BreakpointLocationSP loc_sp = m_breakpoint->GetLocationAtIndex(0);
 138             lldb::addr_t cur_load_location = m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
 139             if (cur_load_location != m_resolved_addr)
 140             {
 141                 m_resolved_addr = cur_load_location;
 142                 loc_sp->ClearBreakpointSite();
 143                 loc_sp->ResolveBreakpointSite();
 144             }
 145         }
 146     }
 147     return Searcher::eCallbackReturnStop;
 148 }
 149
 150 Searcher::Depth
 151 BreakpointResolverAddress::GetDepth()
 152 {
 153     return Searcher::eDepthTarget;
 154 }
 155
 156 void
 157 BreakpointResolverAddress::GetDescription (Stream *s)
 158 {
 159     s->PutCString ("address = ");
 160     m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(), Address::DumpStyleModuleWithFileAddress, Address::DumpStyleLoadAddress);
 161 }
 162
 163 void
 164 BreakpointResolverAddress::Dump (Stream *s) const
 165 {
 166
 167 }
 168
 169 lldb::BreakpointResolverSP
 170 BreakpointResolverAddress::CopyForBreakpoint (Breakpoint &breakpoint)
 171 {
 172     lldb::BreakpointResolverSP ret_sp(new BreakpointResolverAddress(&breakpoint, m_addr));
 173     return ret_sp;
 174 }
 175