1 //===-- BreakpointResolver.cpp ----------------------------------*- C++ -*-===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 #include "lldb/Breakpoint/BreakpointResolver.h"
14 // Other libraries and framework includes
16 #include "lldb/Breakpoint/Breakpoint.h"
17 #include "lldb/Breakpoint/BreakpointLocation.h"
18 // Have to include the other breakpoint resolver types here so the static create
19 // from StructuredData can call them.
20 #include "lldb/Breakpoint/BreakpointResolverAddress.h"
21 #include "lldb/Breakpoint/BreakpointResolverFileLine.h"
22 #include "lldb/Breakpoint/BreakpointResolverFileRegex.h"
23 #include "lldb/Breakpoint/BreakpointResolverName.h"
24 #include "lldb/Core/Address.h"
25 #include "lldb/Core/ModuleList.h"
26 #include "lldb/Core/SearchFilter.h"
27 #include "lldb/Symbol/CompileUnit.h"
28 #include "lldb/Symbol/Function.h"
29 #include "lldb/Symbol/SymbolContext.h"
30 #include "lldb/Target/Target.h"
31 #include "lldb/Utility/Log.h"
32 #include "lldb/Utility/Stream.h"
33 #include "lldb/Utility/StreamString.h"
35 using namespace lldb_private;
38 //----------------------------------------------------------------------
39 // BreakpointResolver:
40 //----------------------------------------------------------------------
41 const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
42 "SymbolName", "SourceRegex",
43 "Exception", "Unknown"};
45 const char *BreakpointResolver::g_option_names[static_cast<uint32_t>(
46 BreakpointResolver::OptionNames::LastOptionName)] = {
47 "AddressOffset", "Exact", "FileName", "Inlines", "Language",
48 "LineNumber", "ModuleName", "NameMask", "Offset", "Regex",
49 "SectionName", "SkipPrologue", "SymbolNames"};
51 const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
52 if (type > LastKnownResolverType)
53 return g_ty_to_name[UnknownResolver];
55 return g_ty_to_name[type];
58 BreakpointResolver::ResolverTy
59 BreakpointResolver::NameToResolverTy(llvm::StringRef name) {
60 for (size_t i = 0; i < LastKnownResolverType; i++) {
61 if (name == g_ty_to_name[i])
64 return UnknownResolver;
67 BreakpointResolver::BreakpointResolver(Breakpoint *bkpt,
68 const unsigned char resolverTy,
70 : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
72 BreakpointResolver::~BreakpointResolver() {}
74 BreakpointResolverSP BreakpointResolver::CreateFromStructuredData(
75 const StructuredData::Dictionary &resolver_dict, Status &error) {
76 BreakpointResolverSP result_sp;
77 if (!resolver_dict.IsValid()) {
78 error.SetErrorString("Can't deserialize from an invalid data object.");
82 llvm::StringRef subclass_name;
84 bool success = resolver_dict.GetValueForKeyAsString(
85 GetSerializationSubclassKey(), subclass_name);
88 error.SetErrorStringWithFormat(
89 "Resolver data missing subclass resolver key");
93 ResolverTy resolver_type = NameToResolverTy(subclass_name);
94 if (resolver_type == UnknownResolver) {
95 error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
100 StructuredData::Dictionary *subclass_options = nullptr;
101 success = resolver_dict.GetValueForKeyAsDictionary(
102 GetSerializationSubclassOptionsKey(), subclass_options);
103 if (!success || !subclass_options || !subclass_options->IsValid()) {
104 error.SetErrorString("Resolver data missing subclass options key.");
109 success = subclass_options->GetValueForKeyAsInteger(
110 GetKey(OptionNames::Offset), offset);
112 error.SetErrorString("Resolver data missing offset options key.");
116 BreakpointResolver *resolver;
118 switch (resolver_type) {
119 case FileLineResolver:
120 resolver = BreakpointResolverFileLine::CreateFromStructuredData(
121 nullptr, *subclass_options, error);
123 case AddressResolver:
124 resolver = BreakpointResolverAddress::CreateFromStructuredData(
125 nullptr, *subclass_options, error);
128 resolver = BreakpointResolverName::CreateFromStructuredData(
129 nullptr, *subclass_options, error);
131 case FileRegexResolver:
132 resolver = BreakpointResolverFileRegex::CreateFromStructuredData(
133 nullptr, *subclass_options, error);
135 case ExceptionResolver:
136 error.SetErrorString("Exception resolvers are hard.");
139 llvm_unreachable("Should never get an unresolvable resolver type.");
142 if (!error.Success()) {
145 // Add on the global offset option:
146 resolver->SetOffset(offset);
147 return BreakpointResolverSP(resolver);
151 StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict(
152 StructuredData::DictionarySP options_dict_sp) {
153 if (!options_dict_sp || !options_dict_sp->IsValid())
154 return StructuredData::DictionarySP();
156 StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary());
157 type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName());
158 type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp);
160 // Add the m_offset to the dictionary:
161 options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset);
166 void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) {
170 void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
171 ModuleList &modules) {
172 filter.SearchInModuleList(*this, modules);
175 void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
176 filter.Search(*this);
179 void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter,
180 SymbolContextList &sc_list,
182 llvm::StringRef log_ident) {
183 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
185 while (sc_list.GetSize() > 0) {
186 SymbolContextList tmp_sc_list;
187 unsigned current_idx = 0;
189 bool first_entry = true;
191 FileSpec match_file_spec;
192 FileSpec match_original_file_spec;
193 uint32_t closest_line_number = UINT32_MAX;
195 // Pull out the first entry, and all the others that match its file spec,
196 // and stuff them in the tmp list.
197 while (current_idx < sc_list.GetSize()) {
200 sc_list.GetContextAtIndex(current_idx, sc);
202 match_file_spec = sc.line_entry.file;
203 match_original_file_spec = sc.line_entry.original_file;
207 matches = ((sc.line_entry.file == match_file_spec) ||
208 (sc.line_entry.original_file == match_original_file_spec));
211 tmp_sc_list.Append(sc);
212 sc_list.RemoveContextAtIndex(current_idx);
214 // ResolveSymbolContext will always return a number that is >= the line
215 // number you pass in.
216 // So the smaller line number is always better.
217 if (sc.line_entry.line < closest_line_number)
218 closest_line_number = sc.line_entry.line;
223 // Okay, we've found the closest line number match, now throw away all the
227 while (current_idx < tmp_sc_list.GetSize()) {
228 if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
229 if (sc.line_entry.line != closest_line_number)
230 tmp_sc_list.RemoveContextAtIndex(current_idx);
236 // Next go through and see if there are line table entries that are
237 // contiguous, and if so keep only the
238 // first of the contiguous range:
241 std::map<Block *, lldb::addr_t> blocks_with_breakpoints;
243 while (current_idx < tmp_sc_list.GetSize()) {
244 if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
245 if (blocks_with_breakpoints.find(sc.block) !=
246 blocks_with_breakpoints.end())
247 tmp_sc_list.RemoveContextAtIndex(current_idx);
249 blocks_with_breakpoints.insert(std::pair<Block *, lldb::addr_t>(
250 sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress()));
256 // and make breakpoints out of the closest line number match.
258 uint32_t tmp_sc_list_size = tmp_sc_list.GetSize();
260 for (uint32_t i = 0; i < tmp_sc_list_size; i++) {
261 if (tmp_sc_list.GetContextAtIndex(i, sc)) {
262 Address line_start = sc.line_entry.range.GetBaseAddress();
263 if (line_start.IsValid()) {
264 if (filter.AddressPasses(line_start)) {
265 // If the line number is before the prologue end, move it there...
266 bool skipped_prologue = false;
269 Address prologue_addr(
270 sc.function->GetAddressRange().GetBaseAddress());
271 if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
272 const uint32_t prologue_byte_size =
273 sc.function->GetPrologueByteSize();
274 if (prologue_byte_size) {
275 prologue_addr.Slide(prologue_byte_size);
277 if (filter.AddressPasses(prologue_addr)) {
278 skipped_prologue = true;
279 line_start = prologue_addr;
286 BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
287 if (log && bp_loc_sp && !m_breakpoint->IsInternal()) {
289 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
290 log->Printf("Added location (skipped prologue: %s): %s \n",
291 skipped_prologue ? "yes" : "no", s.GetData());
294 log->Printf("Breakpoint %s at file address 0x%" PRIx64
295 " didn't pass the filter.\n",
296 log_ident.str().c_str(), line_start.GetFileAddress());
301 "error: Unable to set breakpoint %s at file address 0x%" PRIx64
303 log_ident.str().c_str(), line_start.GetFileAddress());
310 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
311 bool *new_location) {
312 loc_addr.Slide(m_offset);
313 return m_breakpoint->AddLocation(loc_addr, new_location);
316 void BreakpointResolver::SetOffset(lldb::addr_t offset) {
317 // There may already be an offset, so we are actually adjusting location
318 // addresses by the difference.
319 // lldb::addr_t slide = offset - m_offset;
320 // FIXME: We should go fix up all the already set locations for the new slide.