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