contrib/llvm/tools/lldb/source/Breakpoint/BreakpointResolver.cpp

   1 //===-- BreakpointResolver.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/BreakpointResolver.h"
  11
  12 // C Includes
  13 // C++ Includes
  14 // Other libraries and framework includes
  15 // Project 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
  19 // create 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"
  34
  35 using namespace lldb_private;
  36 using namespace lldb;
  37
  38 //----------------------------------------------------------------------
  39 // BreakpointResolver:
  40 //----------------------------------------------------------------------
  41 const char *BreakpointResolver::g_ty_to_name[] = {"FileAndLine", "Address",
  42                                                   "SymbolName",  "SourceRegex",
  43                                                   "Exception",   "Unknown"};
  44
  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"};
  50
  51 const char *BreakpointResolver::ResolverTyToName(enum ResolverTy type) {
  52   if (type > LastKnownResolverType)
  53     return g_ty_to_name[UnknownResolver];
  54
  55   return g_ty_to_name[type];
  56 }
  57
  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])
  62       return (ResolverTy)i;
  63   }
  64   return UnknownResolver;
  65 }
  66
  67 BreakpointResolver::BreakpointResolver(Breakpoint *bkpt,
  68                                        const unsigned char resolverTy,
  69                                        lldb::addr_t offset)
  70     : m_breakpoint(bkpt), m_offset(offset), SubclassID(resolverTy) {}
  71
  72 BreakpointResolver::~BreakpointResolver() {}
  73
  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.");
  79     return result_sp;
  80   }
  81
  82   llvm::StringRef subclass_name;
  83
  84   bool success = resolver_dict.GetValueForKeyAsString(
  85       GetSerializationSubclassKey(), subclass_name);
  86
  87   if (!success) {
  88     error.SetErrorStringWithFormat(
  89         "Resolver data missing subclass resolver key");
  90     return result_sp;
  91   }
  92
  93   ResolverTy resolver_type = NameToResolverTy(subclass_name);
  94   if (resolver_type == UnknownResolver) {
  95     error.SetErrorStringWithFormatv("Unknown resolver type: {0}.",
  96                                     subclass_name);
  97     return result_sp;
  98   }
  99
 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.");
 105     return result_sp;
 106   }
 107
 108   lldb::addr_t offset;
 109   success = subclass_options->GetValueForKeyAsInteger(
 110       GetKey(OptionNames::Offset), offset);
 111   if (!success) {
 112     error.SetErrorString("Resolver data missing offset options key.");
 113     return result_sp;
 114   }
 115
 116   BreakpointResolver *resolver;
 117
 118   switch (resolver_type) {
 119   case FileLineResolver:
 120     resolver = BreakpointResolverFileLine::CreateFromStructuredData(
 121         nullptr, *subclass_options, error);
 122     break;
 123   case AddressResolver:
 124     resolver = BreakpointResolverAddress::CreateFromStructuredData(
 125         nullptr, *subclass_options, error);
 126     break;
 127   case NameResolver:
 128     resolver = BreakpointResolverName::CreateFromStructuredData(
 129         nullptr, *subclass_options, error);
 130     break;
 131   case FileRegexResolver:
 132     resolver = BreakpointResolverFileRegex::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
 151 StructuredData::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
 166 void BreakpointResolver::SetBreakpoint(Breakpoint *bkpt) {
 167   m_breakpoint = bkpt;
 168 }
 169
 170 void BreakpointResolver::ResolveBreakpointInModules(SearchFilter &filter,
 171                                                     ModuleList &modules) {
 172   filter.SearchInModuleList(*this, modules);
 173 }
 174
 175 void BreakpointResolver::ResolveBreakpoint(SearchFilter &filter) {
 176   filter.Search(*this);
 177 }
 178
 179 void BreakpointResolver::SetSCMatchesByLine(SearchFilter &filter,
 180                                             SymbolContextList &sc_list,
 181                                             bool skip_prologue,
 182                                             llvm::StringRef log_ident) {
 183   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_BREAKPOINTS));
 184
 185   while (sc_list.GetSize() > 0) {
 186     SymbolContextList tmp_sc_list;
 187     unsigned current_idx = 0;
 188     SymbolContext sc;
 189     bool first_entry = true;
 190
 191     FileSpec match_file_spec;
 192     FileSpec match_original_file_spec;
 193     uint32_t closest_line_number = UINT32_MAX;
 194
 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()) {
 198       bool matches;
 199
 200       sc_list.GetContextAtIndex(current_idx, sc);
 201       if (first_entry) {
 202         match_file_spec = sc.line_entry.file;
 203         match_original_file_spec = sc.line_entry.original_file;
 204         matches = true;
 205         first_entry = false;
 206       } else
 207         matches = ((sc.line_entry.file == match_file_spec) ||
 208                    (sc.line_entry.original_file == match_original_file_spec));
 209
 210       if (matches) {
 211         tmp_sc_list.Append(sc);
 212         sc_list.RemoveContextAtIndex(current_idx);
 213
 214         // ResolveSymbolContext will always return a number that is >= the line
 215         // number you pass in. So the smaller line number is always better.
 216         if (sc.line_entry.line < closest_line_number)
 217           closest_line_number = sc.line_entry.line;
 218       } else
 219         current_idx++;
 220     }
 221
 222     // Okay, we've found the closest line number match, now throw away all the
 223     // others:
 224
 225     current_idx = 0;
 226     while (current_idx < tmp_sc_list.GetSize()) {
 227       if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
 228         if (sc.line_entry.line != closest_line_number)
 229           tmp_sc_list.RemoveContextAtIndex(current_idx);
 230         else
 231           current_idx++;
 232       }
 233     }
 234
 235     // Next go through and see if there are line table entries that are
 236     // contiguous, and if so keep only the first of the contiguous range:
 237
 238     current_idx = 0;
 239     std::map<Block *, lldb::addr_t> blocks_with_breakpoints;
 240
 241     while (current_idx < tmp_sc_list.GetSize()) {
 242       if (tmp_sc_list.GetContextAtIndex(current_idx, sc)) {
 243         if (blocks_with_breakpoints.find(sc.block) !=
 244             blocks_with_breakpoints.end())
 245           tmp_sc_list.RemoveContextAtIndex(current_idx);
 246         else {
 247           blocks_with_breakpoints.insert(std::pair<Block *, lldb::addr_t>(
 248               sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress()));
 249           current_idx++;
 250         }
 251       }
 252     }
 253
 254     // and make breakpoints out of the closest line number match.
 255
 256     uint32_t tmp_sc_list_size = tmp_sc_list.GetSize();
 257
 258     for (uint32_t i = 0; i < tmp_sc_list_size; i++) {
 259       if (tmp_sc_list.GetContextAtIndex(i, sc)) {
 260         Address line_start = sc.line_entry.range.GetBaseAddress();
 261         if (line_start.IsValid()) {
 262           if (filter.AddressPasses(line_start)) {
 263             // If the line number is before the prologue end, move it there...
 264             bool skipped_prologue = false;
 265             if (skip_prologue) {
 266               if (sc.function) {
 267                 Address prologue_addr(
 268                     sc.function->GetAddressRange().GetBaseAddress());
 269                 if (prologue_addr.IsValid() && (line_start == prologue_addr)) {
 270                   const uint32_t prologue_byte_size =
 271                       sc.function->GetPrologueByteSize();
 272                   if (prologue_byte_size) {
 273                     prologue_addr.Slide(prologue_byte_size);
 274
 275                     if (filter.AddressPasses(prologue_addr)) {
 276                       skipped_prologue = true;
 277                       line_start = prologue_addr;
 278                     }
 279                   }
 280                 }
 281               }
 282             }
 283
 284             BreakpointLocationSP bp_loc_sp(AddLocation(line_start));
 285             if (log && bp_loc_sp && !m_breakpoint->IsInternal()) {
 286               StreamString s;
 287               bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose);
 288               log->Printf("Added location (skipped prologue: %s): %s \n",
 289                           skipped_prologue ? "yes" : "no", s.GetData());
 290             }
 291           } else if (log) {
 292             log->Printf("Breakpoint %s at file address 0x%" PRIx64
 293                         " didn't pass the filter.\n",
 294                         log_ident.str().c_str(), line_start.GetFileAddress());
 295           }
 296         } else {
 297           if (log)
 298             log->Printf(
 299                 "error: Unable to set breakpoint %s at file address 0x%" PRIx64
 300                 "\n",
 301                 log_ident.str().c_str(), line_start.GetFileAddress());
 302         }
 303       }
 304     }
 305   }
 306 }
 307
 308 BreakpointLocationSP BreakpointResolver::AddLocation(Address loc_addr,
 309                                                      bool *new_location) {
 310   loc_addr.Slide(m_offset);
 311   return m_breakpoint->AddLocation(loc_addr, new_location);
 312 }
 313
 314 void BreakpointResolver::SetOffset(lldb::addr_t offset) {
 315   // There may already be an offset, so we are actually adjusting location
 316   // addresses by the difference.
 317   // lldb::addr_t slide = offset - m_offset;
 318   // FIXME: We should go fix up all the already set locations for the new slide.
 319
 320   m_offset = offset;
 321 }