BreakpointResolverAddress.cpp revision 360784 
1//===-- BreakpointResolverAddress.cpp ---------------------------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8
9#include "lldb/Breakpoint/BreakpointResolverAddress.h"
10
11
12#include "lldb/Breakpoint/BreakpointLocation.h"
13#include "lldb/Core/Module.h"
14#include "lldb/Core/Section.h"
15#include "lldb/Target/Process.h"
16#include "lldb/Target/Target.h"
17#include "lldb/Utility/Log.h"
18#include "lldb/Utility/StreamString.h"
19
20using namespace lldb;
21using namespace lldb_private;
22
23// BreakpointResolverAddress:
24BreakpointResolverAddress::BreakpointResolverAddress(
25    Breakpoint *bkpt, const Address &addr, const FileSpec &module_spec)
26    : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
27      m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS),
28      m_module_filespec(module_spec) {}
29
30BreakpointResolverAddress::BreakpointResolverAddress(Breakpoint *bkpt,
31                                                     const Address &addr)
32    : BreakpointResolver(bkpt, BreakpointResolver::AddressResolver),
33      m_addr(addr), m_resolved_addr(LLDB_INVALID_ADDRESS), m_module_filespec() {
34}
35
36BreakpointResolverAddress::~BreakpointResolverAddress() {}
37
38BreakpointResolver *BreakpointResolverAddress::CreateFromStructuredData(
39    Breakpoint *bkpt, const StructuredData::Dictionary &options_dict,
40    Status &error) {
41  llvm::StringRef module_name;
42  lldb::addr_t addr_offset;
43  FileSpec module_filespec;
44  bool success;
45
46  success = options_dict.GetValueForKeyAsInteger(
47      GetKey(OptionNames::AddressOffset), addr_offset);
48  if (!success) {
49    error.SetErrorString("BRFL::CFSD: Couldn't find address offset entry.");
50    return nullptr;
51  }
52  Address address(addr_offset);
53
54  success = options_dict.HasKey(GetKey(OptionNames::ModuleName));
55  if (success) {
56    success = options_dict.GetValueForKeyAsString(
57        GetKey(OptionNames::ModuleName), module_name);
58    if (!success) {
59      error.SetErrorString("BRA::CFSD: Couldn't read module name entry.");
60      return nullptr;
61    }
62    module_filespec.SetFile(module_name, FileSpec::Style::native);
63  }
64  return new BreakpointResolverAddress(bkpt, address, module_filespec);
65}
66
67StructuredData::ObjectSP
68BreakpointResolverAddress::SerializeToStructuredData() {
69  StructuredData::DictionarySP options_dict_sp(
70      new StructuredData::Dictionary());
71  SectionSP section_sp = m_addr.GetSection();
72  if (section_sp) {
73    ModuleSP module_sp = section_sp->GetModule();
74    ConstString module_name;
75    if (module_sp)
76      module_name.SetCString(module_name.GetCString());
77
78    options_dict_sp->AddStringItem(GetKey(OptionNames::ModuleName),
79                                   module_name.GetCString());
80    options_dict_sp->AddIntegerItem(GetKey(OptionNames::AddressOffset),
81                                    m_addr.GetOffset());
82  } else {
83    options_dict_sp->AddIntegerItem(GetKey(OptionNames::AddressOffset),
84                                    m_addr.GetOffset());
85    if (m_module_filespec) {
86      options_dict_sp->AddStringItem(GetKey(OptionNames::ModuleName),
87                                     m_module_filespec.GetPath());
88    }
89  }
90
91  return WrapOptionsDict(options_dict_sp);
92  return StructuredData::ObjectSP();
93}
94
95void BreakpointResolverAddress::ResolveBreakpoint(SearchFilter &filter) {
96  // If the address is not section relative, then we should not try to re-
97  // resolve it, it is just some random address and we wouldn't know what to do
98  // on reload.  But if it is section relative, we need to re-resolve it since
99  // the section it's in may have shifted on re-run.
100  bool re_resolve = false;
101  if (m_addr.GetSection() || m_module_filespec)
102    re_resolve = true;
103  else if (m_breakpoint->GetNumLocations() == 0)
104    re_resolve = true;
105
106  if (re_resolve)
107    BreakpointResolver::ResolveBreakpoint(filter);
108}
109
110void BreakpointResolverAddress::ResolveBreakpointInModules(
111    SearchFilter &filter, ModuleList &modules) {
112  // See comment in ResolveBreakpoint.
113  bool re_resolve = false;
114  if (m_addr.GetSection())
115    re_resolve = true;
116  else if (m_breakpoint->GetNumLocations() == 0)
117    re_resolve = true;
118
119  if (re_resolve)
120    BreakpointResolver::ResolveBreakpointInModules(filter, modules);
121}
122
123Searcher::CallbackReturn BreakpointResolverAddress::SearchCallback(
124    SearchFilter &filter, SymbolContext &context, Address *addr) {
125  assert(m_breakpoint != nullptr);
126
127  if (filter.AddressPasses(m_addr)) {
128    if (m_breakpoint->GetNumLocations() == 0) {
129      // If the address is just an offset, and we're given a module, see if we
130      // can find the appropriate module loaded in the binary, and fix up
131      // m_addr to use that.
132      if (!m_addr.IsSectionOffset() && m_module_filespec) {
133        Target &target = m_breakpoint->GetTarget();
134        ModuleSpec module_spec(m_module_filespec);
135        ModuleSP module_sp = target.GetImages().FindFirstModule(module_spec);
136        if (module_sp) {
137          Address tmp_address;
138          if (module_sp->ResolveFileAddress(m_addr.GetOffset(), tmp_address))
139            m_addr = tmp_address;
140        }
141      }
142
143      m_resolved_addr = m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
144      BreakpointLocationSP bp_loc_sp(AddLocation(m_addr));
145      if (bp_loc_sp && !m_breakpoint->IsInternal()) {
146        StreamString s;
147        bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
148        Log *log(
149            lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
150        LLDB_LOGF(log, "Added location: %s\n", s.GetData());
151      }
152    } else {
153      BreakpointLocationSP loc_sp = m_breakpoint->GetLocationAtIndex(0);
154      lldb::addr_t cur_load_location =
155          m_addr.GetLoadAddress(&m_breakpoint->GetTarget());
156      if (cur_load_location != m_resolved_addr) {
157        m_resolved_addr = cur_load_location;
158        loc_sp->ClearBreakpointSite();
159        loc_sp->ResolveBreakpointSite();
160      }
161    }
162  }
163  return Searcher::eCallbackReturnStop;
164}
165
166lldb::SearchDepth BreakpointResolverAddress::GetDepth() {
167  return lldb::eSearchDepthTarget;
168}
169
170void BreakpointResolverAddress::GetDescription(Stream *s) {
171  s->PutCString("address = ");
172  m_addr.Dump(s, m_breakpoint->GetTarget().GetProcessSP().get(),
173              Address::DumpStyleModuleWithFileAddress,
174              Address::DumpStyleLoadAddress);
175}
176
177void BreakpointResolverAddress::Dump(Stream *s) const {}
178
179lldb::BreakpointResolverSP
180BreakpointResolverAddress::CopyForBreakpoint(Breakpoint &breakpoint) {
181  lldb::BreakpointResolverSP ret_sp(
182      new BreakpointResolverAddress(&breakpoint, m_addr));
183  return ret_sp;
184}
185