BreakpointResolver.cpp revision 355940
1//===-- BreakpointResolver.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/BreakpointResolver.h" 10 11#include "lldb/Breakpoint/Breakpoint.h" 12#include "lldb/Breakpoint/BreakpointLocation.h" 13// Have to include the other breakpoint resolver types here so the static 14// create from StructuredData can call them. 15#include "lldb/Breakpoint/BreakpointResolverAddress.h" 16#include "lldb/Breakpoint/BreakpointResolverFileLine.h" 17#include "lldb/Breakpoint/BreakpointResolverFileRegex.h" 18#include "lldb/Breakpoint/BreakpointResolverName.h" 19#include "lldb/Breakpoint/BreakpointResolverScripted.h" 20#include "lldb/Core/Address.h" 21#include "lldb/Core/ModuleList.h" 22#include "lldb/Core/SearchFilter.h" 23#include "lldb/Symbol/CompileUnit.h" 24#include "lldb/Symbol/Function.h" 25#include "lldb/Symbol/SymbolContext.h" 26#include "lldb/Target/Target.h" 27#include "lldb/Utility/Log.h" 28#include "lldb/Utility/Stream.h" 29#include "lldb/Utility/StreamString.h" 30 31using namespace lldb_private; 32using namespace lldb; 33 34// BreakpointResolver: 35const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address", 36 "SymbolName", "SourceRegex", 37 "Exception", "Unknown"}; 38 39const char *BreakpointResolver::g_option_names[static_cast<uint32_t>( 40 BreakpointResolver::OptionNames::LastOptionName)] = { 41 "AddressOffset", "Exact", "FileName", "Inlines", "Language", 42 "LineNumber", "Column", "ModuleName", "NameMask", "Offset", 43 "PythonClass", "Regex", "ScriptArgs", "SectionName", "SearchDepth", 44 "SkipPrologue", "SymbolNames"}; 45 46const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) { 47 if (type > LastKnownResolverType) 48 return g_ty_to_name[UnknownResolver]; 49 50 return g_ty_to_name[type]; 51} 52 53BreakpointResolver::ResolverTy 54BreakpointResolver::NameToResolverTy(llvm::StringRef name) { 55 for (size_t i = 0; i < LastKnownResolverType; i++) { 56 if (name == g_ty_to_name[i]) 57 return (ResolverTy)i; 58 } 59 return UnknownResolver; 60} 61 62BreakpointResolver::BreakpointResolver(Breakpoint *bkpt, 63 const unsigned char resolverTy, 64 lldb::addr_t offset) 65 : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {} 66 67BreakpointResolver::~BreakpointResolver() {} 68 69BreakpointResolverSP BreakpointResolver::CreateFromStructuredData( 70 const StructuredData::Dictionary &resolver_dict, Status &error) { 71 BreakpointResolverSP result_sp; 72 if (!resolver_dict.IsValid()) { 73 error.SetErrorString("Can't deserialize from an invalid data object."); 74 return result_sp; 75 } 76 77 llvm::StringRef subclass_name; 78 79 bool success = resolver_dict.GetValueForKeyAsString( 80 GetSerializationSubclassKey(), subclass_name); 81 82 if (!success) { 83 error.SetErrorStringWithFormat( 84 "Resolver data missing subclass resolver key"); 85 return result_sp; 86 } 87 88 ResolverTy resolver_type = NameToResolverTy(subclass_name); 89 if (resolver_type == UnknownResolver) { 90 error.SetErrorStringWithFormatv("Unknown resolver type: {0}.", 91 subclass_name); 92 return result_sp; 93 } 94 95 StructuredData::Dictionary *subclass_options = nullptr; 96 success = resolver_dict.GetValueForKeyAsDictionary( 97 GetSerializationSubclassOptionsKey(), subclass_options); 98 if (!success || !subclass_options || !subclass_options->IsValid()) { 99 error.SetErrorString("Resolver data missing subclass options key."); 100 return result_sp; 101 } 102 103 lldb::addr_t offset; 104 success = subclass_options->GetValueForKeyAsInteger( 105 GetKey(OptionNames::Offset), offset); 106 if (!success) { 107 error.SetErrorString("Resolver data missing offset options key."); 108 return result_sp; 109 } 110 111 BreakpointResolver *resolver; 112 113 switch (resolver_type) { 114 case FileLineResolver: 115 resolver = BreakpointResolverFileLine::CreateFromStructuredData( 116 nullptr, *subclass_options, error); 117 break; 118 case AddressResolver: 119 resolver = BreakpointResolverAddress::CreateFromStructuredData( 120 nullptr, *subclass_options, error); 121 break; 122 case NameResolver: 123 resolver = BreakpointResolverName::CreateFromStructuredData( 124 nullptr, *subclass_options, error); 125 break; 126 case FileRegexResolver: 127 resolver = BreakpointResolverFileRegex::CreateFromStructuredData( 128 nullptr, *subclass_options, error); 129 break; 130 case PythonResolver: 131 resolver = BreakpointResolverScripted::CreateFromStructuredData( 132 nullptr, *subclass_options, error); 133 break; 134 case ExceptionResolver: 135 error.SetErrorString("Exception resolvers are hard."); 136 break; 137 default: 138 llvm_unreachable("Should never get an unresolvable resolver type."); 139 } 140 141 if (!error.Success()) { 142 return result_sp; 143 } else { 144 // Add on the global offset option: 145 resolver->SetOffset(offset); 146 return BreakpointResolverSP(resolver); 147 } 148} 149 150StructuredData::DictionarySP BreakpointResolver::WrapOptionsDict( 151 StructuredData::DictionarySP options_dict_sp) { 152 if (!options_dict_sp || !options_dict_sp->IsValid()) 153 return StructuredData::DictionarySP(); 154 155 StructuredData::DictionarySP type_dict_sp(new StructuredData::Dictionary()); 156 type_dict_sp->AddStringItem(GetSerializationSubclassKey(), GetResolverName()); 157 type_dict_sp->AddItem(GetSerializationSubclassOptionsKey(), options_dict_sp); 158 159 // Add the m_offset to the dictionary: 160 options_dict_sp->AddIntegerItem(GetKey(OptionNames::Offset), m_offset); 161 162 return type_dict_sp; 163} 164 165void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) { 166 m_breakpoint = bkpt; 167 NotifyBreakpointSet(); 168} 169 170void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter, 171 ModuleList &modules) { 172 filter.SearchInModuleList(*this, modules); 173} 174 175void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) { 176 filter.Search(*this); 177} 178 179namespace { 180struct SourceLoc { 181 uint32_t line = UINT32_MAX; 182 uint32_t column; 183 SourceLoc(uint32_t l, uint32_t c) : line(l), column(c ? c : UINT32_MAX) {} 184 SourceLoc(const SymbolContext &sc) 185 : line(sc.line_entry.line), 186 column(sc.line_entry.column ? sc.line_entry.column : UINT32_MAX) {} 187}; 188 189bool operator<(const SourceLoc a, const SourceLoc b) { 190 if (a.line < b.line) 191 return true; 192 if (a.line > b.line) 193 return false; 194 uint32_t a_col = a.column ? a.column : UINT32_MAX; 195 uint32_t b_col = b.column ? b.column : UINT32_MAX; 196 return a_col < b_col; 197} 198} // namespace 199 200void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter, 201 SymbolContextList &sc_list, 202 bool skip_prologue, 203 llvm::StringRef log_ident, 204 uint32_t line, uint32_t column) { 205 llvm::SmallVector<SymbolContext, 16> all_scs; 206 for (uint32_t i = 0; i < sc_list.GetSize(); ++i) 207 all_scs.push_back(sc_list[i]); 208 209 while (all_scs.size()) { 210 uint32_t closest_line = UINT32_MAX; 211 212 // Move all the elements with a matching file spec to the end. 213 auto &match = all_scs[0]; 214 auto worklist_begin = std::partition( 215 all_scs.begin(), all_scs.end(), [&](const SymbolContext &sc) { 216 if (sc.line_entry.file == match.line_entry.file || 217 sc.line_entry.original_file == match.line_entry.original_file) { 218 // When a match is found, keep track of the smallest line number. 219 closest_line = std::min(closest_line, sc.line_entry.line); 220 return false; 221 } 222 return true; 223 }); 224 225 // (worklist_begin, worklist_end) now contains all entries for one filespec. 226 auto worklist_end = all_scs.end(); 227 228 if (column) { 229 // If a column was requested, do a more precise match and only 230 // return the first location that comes after or at the 231 // requested location. 232 SourceLoc requested(line, column); 233 // First, filter out all entries left of the requested column. 234 worklist_end = std::remove_if( 235 worklist_begin, worklist_end, 236 [&](const SymbolContext &sc) { return SourceLoc(sc) < requested; }); 237 // Sort the remaining entries by (line, column). 238 llvm::sort(worklist_begin, worklist_end, 239 [](const SymbolContext &a, const SymbolContext &b) { 240 return SourceLoc(a) < SourceLoc(b); 241 }); 242 243 // Filter out all locations with a source location after the closest match. 244 if (worklist_begin != worklist_end) 245 worklist_end = std::remove_if( 246 worklist_begin, worklist_end, [&](const SymbolContext &sc) { 247 return SourceLoc(*worklist_begin) < SourceLoc(sc); 248 }); 249 } else { 250 // Remove all entries with a larger line number. 251 // ResolveSymbolContext will always return a number that is >= 252 // the line number you pass in. So the smaller line number is 253 // always better. 254 worklist_end = std::remove_if(worklist_begin, worklist_end, 255 [&](const SymbolContext &sc) { 256 return closest_line != sc.line_entry.line; 257 }); 258 } 259 260 // Sort by file address. 261 llvm::sort(worklist_begin, worklist_end, 262 [](const SymbolContext &a, const SymbolContext &b) { 263 return a.line_entry.range.GetBaseAddress().GetFileAddress() < 264 b.line_entry.range.GetBaseAddress().GetFileAddress(); 265 }); 266 267 // Go through and see if there are line table entries that are 268 // contiguous, and if so keep only the first of the contiguous range. 269 // We do this by picking the first location in each lexical block. 270 llvm::SmallDenseSet<Block *, 8> blocks_with_breakpoints; 271 for (auto first = worklist_begin; first != worklist_end; ++first) { 272 assert(!blocks_with_breakpoints.count(first->block)); 273 blocks_with_breakpoints.insert(first->block); 274 worklist_end = 275 std::remove_if(std::next(first), worklist_end, 276 [&](const SymbolContext &sc) { 277 return blocks_with_breakpoints.count(sc.block); 278 }); 279 } 280 281 // Make breakpoints out of the closest line number match. 282 for (auto &sc : llvm::make_range(worklist_begin, worklist_end)) 283 AddLocation(filter, sc, skip_prologue, log_ident); 284 285 // Remove all contexts processed by this iteration. 286 all_scs.erase(worklist_begin, all_scs.end()); 287 } 288} 289 290void BreakpointResolver::AddLocation(SearchFilter &filter, 291 const SymbolContext &sc, 292 bool skip_prologue, 293 llvm::StringRef log_ident) { 294 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS)); 295 Address line_start = sc.line_entry.range.GetBaseAddress(); 296 if (!line_start.IsValid()) { 297 if (log) 298 log->Printf("error: Unable to set breakpoint %s at file address " 299 "0x%" PRIx64 "\n", 300 log_ident.str().c_str(), line_start.GetFileAddress()); 301 return; 302 } 303 304 if (!filter.AddressPasses(line_start)) { 305 if (log) 306 log->Printf("Breakpoint %s at file address 0x%" PRIx64 307 " didn't pass the filter.\n", 308 log_ident.str().c_str(), line_start.GetFileAddress()); 309 } 310 311 // If the line number is before the prologue end, move it there... 312 bool skipped_prologue = false; 313 if (skip_prologue && sc.function) { 314 Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress()); 315 if (prologue_addr.IsValid() && (line_start == prologue_addr)) { 316 const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize(); 317 if (prologue_byte_size) { 318 prologue_addr.Slide(prologue_byte_size); 319 320 if (filter.AddressPasses(prologue_addr)) { 321 skipped_prologue = true; 322 line_start = prologue_addr; 323 } 324 } 325 } 326 } 327 328 BreakpointLocationSP bp_loc_sp(AddLocation(line_start)); 329 if (log && bp_loc_sp && !m_breakpoint->IsInternal()) { 330 StreamString s; 331 bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); 332 log->Printf("Added location (skipped prologue: %s): %s \n", 333 skipped_prologue ? "yes" : "no", s.GetData()); 334 } 335} 336 337BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr, 338 bool *new_location) { 339 loc_addr.Slide(m_offset); 340 return m_breakpoint->AddLocation(loc_addr, new_location); 341} 342 343void BreakpointResolver::SetOffset(lldb::addr_t offset) { 344 // There may already be an offset, so we are actually adjusting location 345 // addresses by the difference. 346 // lldb::addr_t slide = offset - m_offset; 347 // FIXME: We should go fix up all the already set locations for the new 348 // slide. 349 350 m_offset = offset; 351} 352