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/Core/Address.h"
  17 #include "lldb/Breakpoint/Breakpoint.h"
  18 #include "lldb/Breakpoint/BreakpointLocation.h"
  19 #include "lldb/Core/Log.h"
  20 #include "lldb/Core/ModuleList.h"
  21 #include "lldb/Core/SearchFilter.h"
  22 #include "lldb/Core/Stream.h"
  23 #include "lldb/Core/StreamString.h"
  24 #include "lldb/Symbol/SymbolContext.h"
  25 #include "lldb/Target/Target.h"
  26 #include "lldb/Symbol/CompileUnit.h"
  27 #include "lldb/Symbol/Function.h"
  28
  29 using namespace lldb_private;
  30 using namespace lldb;
  31
  32 //----------------------------------------------------------------------
  33 // BreakpointResolver:
  34 //----------------------------------------------------------------------
  35 BreakpointResolver::BreakpointResolver (Breakpoint *bkpt, const unsigned char resolverTy, lldb::addr_t offset) :
  36     m_breakpoint (bkpt),
  37     m_offset(offset),
  38     SubclassID (resolverTy)
  39 {
  40 }
  41
  42 BreakpointResolver::~BreakpointResolver ()
  43 {
  44
  45 }
  46
  47 void
  48 BreakpointResolver::SetBreakpoint (Breakpoint *bkpt)
  49 {
  50     m_breakpoint = bkpt;
  51 }
  52
  53 void
  54 BreakpointResolver::ResolveBreakpointInModules (SearchFilter &filter, ModuleList &modules)
  55 {
  56     filter.SearchInModuleList(*this, modules);
  57 }
  58
  59 void
  60 BreakpointResolver::ResolveBreakpoint (SearchFilter &filter)
  61 {
  62     filter.Search (*this);
  63 }
  64
  65 void
  66 BreakpointResolver::SetSCMatchesByLine (SearchFilter &filter, SymbolContextList &sc_list, bool skip_prologue, const char *log_ident)
  67 {
  68     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS));
  69
  70     while (sc_list.GetSize() > 0)
  71     {
  72         SymbolContextList tmp_sc_list;
  73         unsigned current_idx = 0;
  74         SymbolContext sc;
  75         bool first_entry = true;
  76
  77         FileSpec match_file_spec;
  78         FileSpec match_original_file_spec;
  79         uint32_t closest_line_number = UINT32_MAX;
  80
  81         // Pull out the first entry, and all the others that match its file spec, and stuff them in the tmp list.
  82         while (current_idx < sc_list.GetSize())
  83         {
  84             bool matches;
  85
  86             sc_list.GetContextAtIndex (current_idx, sc);
  87             if (first_entry)
  88             {
  89                 match_file_spec = sc.line_entry.file;
  90                 match_original_file_spec = sc.line_entry.original_file;
  91                 matches = true;
  92                 first_entry = false;
  93             }
  94             else
  95                 matches = ((sc.line_entry.file == match_file_spec) ||
  96                            (sc.line_entry.original_file == match_original_file_spec));
  97
  98             if (matches)
  99             {
 100                 tmp_sc_list.Append (sc);
 101                 sc_list.RemoveContextAtIndex(current_idx);
 102
 103                 // ResolveSymbolContext will always return a number that is >= the line number you pass in.
 104                 // So the smaller line number is always better.
 105                 if (sc.line_entry.line < closest_line_number)
 106                     closest_line_number = sc.line_entry.line;
 107             }
 108             else
 109                 current_idx++;
 110         }
 111
 112         // Okay, we've found the closest line number match, now throw away all the others:
 113
 114         current_idx = 0;
 115         while (current_idx < tmp_sc_list.GetSize())
 116         {
 117             if (tmp_sc_list.GetContextAtIndex(current_idx, sc))
 118             {
 119                 if (sc.line_entry.line != closest_line_number)
 120                     tmp_sc_list.RemoveContextAtIndex(current_idx);
 121                 else
 122                     current_idx++;
 123             }
 124         }
 125
 126         // Next go through and see if there are line table entries that are contiguous, and if so keep only the
 127         // first of the contiguous range:
 128
 129         current_idx = 0;
 130         std::map<Block *, lldb::addr_t> blocks_with_breakpoints;
 131
 132         while (current_idx < tmp_sc_list.GetSize())
 133         {
 134             if (tmp_sc_list.GetContextAtIndex(current_idx, sc))
 135             {
 136                 if (blocks_with_breakpoints.find (sc.block) != blocks_with_breakpoints.end())
 137                     tmp_sc_list.RemoveContextAtIndex(current_idx);
 138                 else
 139                 {
 140                     blocks_with_breakpoints.insert (std::pair<Block *, lldb::addr_t>(sc.block, sc.line_entry.range.GetBaseAddress().GetFileAddress()));
 141                     current_idx++;
 142                 }
 143             }
 144         }
 145
 146         // and make breakpoints out of the closest line number match.
 147
 148         uint32_t tmp_sc_list_size = tmp_sc_list.GetSize();
 149
 150         for (uint32_t i = 0; i < tmp_sc_list_size; i++)
 151         {
 152             if (tmp_sc_list.GetContextAtIndex(i, sc))
 153             {
 154                 Address line_start = sc.line_entry.range.GetBaseAddress();
 155                 if (line_start.IsValid())
 156                 {
 157                     if (filter.AddressPasses(line_start))
 158                     {
 159                         // If the line number is before the prologue end, move it there...
 160                         bool skipped_prologue = false;
 161                         if (skip_prologue)
 162                         {
 163                             if (sc.function)
 164                             {
 165                                 Address prologue_addr(sc.function->GetAddressRange().GetBaseAddress());
 166                                 if (prologue_addr.IsValid() && (line_start == prologue_addr))
 167                                 {
 168                                     const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize();
 169                                     if (prologue_byte_size)
 170                                     {
 171                                         prologue_addr.Slide(prologue_byte_size);
 172
 173                                         if (filter.AddressPasses(prologue_addr))
 174                                         {
 175                                             skipped_prologue = true;
 176                                             line_start = prologue_addr;
 177                                         }
 178                                     }
 179                                 }
 180                             }
 181                         }
 182
 183                         BreakpointLocationSP bp_loc_sp (AddLocation(line_start));
 184                         if (log && bp_loc_sp && !m_breakpoint->IsInternal())
 185                         {
 186                             StreamString s;
 187                             bp_loc_sp->GetDescription (&s, lldb::eDescriptionLevelVerbose);
 188                             log->Printf ("Added location (skipped prologue: %s): %s \n", skipped_prologue ? "yes" : "no", s.GetData());
 189                         }
 190                     }
 191                     else if (log)
 192                     {
 193                         log->Printf ("Breakpoint %s at file address 0x%" PRIx64 " didn't pass the filter.\n",
 194                                      log_ident ? log_ident : "",
 195                                      line_start.GetFileAddress());
 196                     }
 197                 }
 198                 else
 199                 {
 200                     if (log)
 201                         log->Printf ("error: Unable to set breakpoint %s at file address 0x%" PRIx64 "\n",
 202                                      log_ident ? log_ident : "",
 203                                      line_start.GetFileAddress());
 204                 }
 205             }
 206         }
 207     }
 208 }
 209
 210 BreakpointLocationSP
 211 BreakpointResolver::AddLocation(Address loc_addr, bool *new_location)
 212 {
 213     loc_addr.Slide(m_offset);
 214     return m_breakpoint->AddLocation(loc_addr, new_location);
 215 }
 216
 217
 218 void
 219 BreakpointResolver::SetOffset (lldb::addr_t offset)
 220 {
 221     // There may already be an offset, so we are actually adjusting location addresses by the difference.
 222     // lldb::addr_t slide = offset - m_offset;
 223     // FIXME: We should go fix up all the already set locations for the new slide.
 224
 225     m_offset = offset;
 226 }
 227