Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 1 | //===-- BreakpointResolverName.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/BreakpointResolverName.h" |
| 11 | |
| 12 | // C Includes |
| 13 | // C++ Includes |
| 14 | // Other libraries and framework includes |
| 15 | // Project includes |
| 16 | #include "lldb/Breakpoint/BreakpointLocation.h" |
| 17 | #include "lldb/Core/Log.h" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 18 | #include "lldb/Core/Module.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 19 | #include "lldb/Core/StreamString.h" |
Sean Callanan | 3e80cd9 | 2011-10-12 02:08:07 +0000 | [diff] [blame] | 20 | #include "lldb/Symbol/ClangNamespaceDecl.h" |
Greg Clayton | 49ce896 | 2012-08-29 21:13:06 +0000 | [diff] [blame] | 21 | #include "lldb/Symbol/Block.h" |
| 22 | #include "lldb/Symbol/Function.h" |
| 23 | #include "lldb/Symbol/Symbol.h" |
| 24 | #include "lldb/Symbol/SymbolContext.h" |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 25 | |
| 26 | using namespace lldb; |
| 27 | using namespace lldb_private; |
| 28 | |
| 29 | BreakpointResolverName::BreakpointResolverName |
| 30 | ( |
| 31 | Breakpoint *bkpt, |
| 32 | const char *func_name, |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 33 | uint32_t func_name_type_mask, |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 34 | Breakpoint::MatchType type, |
| 35 | bool skip_prologue |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 36 | ) : |
Johnny Chen | a62ad7c | 2010-10-28 17:27:46 +0000 | [diff] [blame] | 37 | BreakpointResolver (bkpt, BreakpointResolver::NameResolver), |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 38 | m_func_name_type_mask (func_name_type_mask), |
| 39 | m_class_name (), |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 40 | m_regex (), |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 41 | m_match_type (type), |
| 42 | m_skip_prologue (skip_prologue) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 43 | { |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 44 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 45 | if (m_match_type == Breakpoint::Regexp) |
| 46 | { |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 47 | if (!m_regex.Compile (func_name)) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 48 | { |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 49 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 50 | |
| 51 | if (log) |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 52 | log->Warning ("function name regexp: \"%s\" did not compile.", func_name); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 53 | } |
| 54 | } |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 55 | else |
| 56 | { |
| 57 | m_func_names.push_back(ConstString(func_name)); |
| 58 | } |
| 59 | } |
| 60 | |
| 61 | BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, |
| 62 | const char *names[], |
| 63 | size_t num_names, |
| 64 | uint32_t name_type_mask, |
| 65 | bool skip_prologue) : |
| 66 | BreakpointResolver (bkpt, BreakpointResolver::NameResolver), |
| 67 | m_func_name_type_mask (name_type_mask), |
Jim Ingham | 4722b10 | 2012-03-06 00:37:27 +0000 | [diff] [blame] | 68 | m_match_type (Breakpoint::Exact), |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 69 | m_skip_prologue (skip_prologue) |
| 70 | { |
| 71 | for (size_t i = 0; i < num_names; i++) |
| 72 | { |
| 73 | m_func_names.push_back (ConstString (names[i])); |
| 74 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 75 | } |
| 76 | |
Jim Ingham | 4722b10 | 2012-03-06 00:37:27 +0000 | [diff] [blame] | 77 | BreakpointResolverName::BreakpointResolverName (Breakpoint *bkpt, |
| 78 | std::vector<std::string> names, |
| 79 | uint32_t name_type_mask, |
| 80 | bool skip_prologue) : |
| 81 | BreakpointResolver (bkpt, BreakpointResolver::NameResolver), |
| 82 | m_func_name_type_mask (name_type_mask), |
| 83 | m_match_type (Breakpoint::Exact), |
| 84 | m_skip_prologue (skip_prologue) |
| 85 | { |
| 86 | size_t num_names = names.size(); |
| 87 | |
| 88 | for (size_t i = 0; i < num_names; i++) |
| 89 | { |
| 90 | m_func_names.push_back (ConstString (names[i].c_str())); |
| 91 | } |
| 92 | } |
| 93 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 94 | BreakpointResolverName::BreakpointResolverName |
| 95 | ( |
| 96 | Breakpoint *bkpt, |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 97 | RegularExpression &func_regex, |
| 98 | bool skip_prologue |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 99 | ) : |
Johnny Chen | a62ad7c | 2010-10-28 17:27:46 +0000 | [diff] [blame] | 100 | BreakpointResolver (bkpt, BreakpointResolver::NameResolver), |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 101 | m_class_name (NULL), |
| 102 | m_regex (func_regex), |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 103 | m_match_type (Breakpoint::Regexp), |
| 104 | m_skip_prologue (skip_prologue) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 105 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 106 | } |
| 107 | |
| 108 | BreakpointResolverName::BreakpointResolverName |
| 109 | ( |
| 110 | Breakpoint *bkpt, |
| 111 | const char *class_name, |
| 112 | const char *method, |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 113 | Breakpoint::MatchType type, |
| 114 | bool skip_prologue |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 115 | ) : |
Johnny Chen | a62ad7c | 2010-10-28 17:27:46 +0000 | [diff] [blame] | 116 | BreakpointResolver (bkpt, BreakpointResolver::NameResolver), |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 117 | m_class_name (class_name), |
| 118 | m_regex (), |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 119 | m_match_type (type), |
| 120 | m_skip_prologue (skip_prologue) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 121 | { |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 122 | m_func_names.push_back(ConstString(method)); |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 123 | } |
| 124 | |
| 125 | BreakpointResolverName::~BreakpointResolverName () |
| 126 | { |
| 127 | } |
| 128 | |
| 129 | // FIXME: Right now we look at the module level, and call the module's "FindFunctions". |
| 130 | // Greg says he will add function tables, maybe at the CompileUnit level to accelerate function |
| 131 | // lookup. At that point, we should switch the depth to CompileUnit, and look in these tables. |
| 132 | |
| 133 | Searcher::CallbackReturn |
| 134 | BreakpointResolverName::SearchCallback |
| 135 | ( |
| 136 | SearchFilter &filter, |
| 137 | SymbolContext &context, |
| 138 | Address *addr, |
| 139 | bool containing |
| 140 | ) |
| 141 | { |
| 142 | SymbolContextList func_list; |
| 143 | SymbolContextList sym_list; |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 144 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 145 | uint32_t i; |
| 146 | bool new_location; |
| 147 | SymbolContext sc; |
| 148 | Address break_addr; |
| 149 | assert (m_breakpoint != NULL); |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 150 | |
Greg Clayton | e005f2c | 2010-11-06 01:53:30 +0000 | [diff] [blame] | 151 | LogSP log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_BREAKPOINTS)); |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 152 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 153 | if (m_class_name) |
| 154 | { |
| 155 | if (log) |
| 156 | log->Warning ("Class/method function specification not supported yet.\n"); |
| 157 | return Searcher::eCallbackReturnStop; |
| 158 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 159 | |
Greg Clayton | 28d5fcc | 2011-01-27 06:44:37 +0000 | [diff] [blame] | 160 | const bool include_symbols = false; |
Sean Callanan | 302d78c | 2012-02-10 22:52:19 +0000 | [diff] [blame] | 161 | const bool include_inlines = true; |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 162 | const bool append = true; |
Jim Ingham | d6d4797 | 2011-09-23 00:54:11 +0000 | [diff] [blame] | 163 | bool filter_by_cu = (filter.GetFilterRequiredItems() & eSymbolContextCompUnit) != 0; |
| 164 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 165 | switch (m_match_type) |
| 166 | { |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 167 | case Breakpoint::Exact: |
| 168 | if (context.module_sp) |
| 169 | { |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 170 | size_t num_names = m_func_names.size(); |
Jason Molenda | bf41e19 | 2012-10-04 22:47:07 +0000 | [diff] [blame] | 171 | for (int j = 0; j < num_names; j++) |
Greg Clayton | d74270e | 2011-09-02 04:03:59 +0000 | [diff] [blame] | 172 | { |
Jason Molenda | bf41e19 | 2012-10-04 22:47:07 +0000 | [diff] [blame] | 173 | uint32_t num_functions = context.module_sp->FindFunctions (m_func_names[j], |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 174 | NULL, |
| 175 | m_func_name_type_mask, |
| 176 | include_symbols, |
| 177 | include_inlines, |
| 178 | append, |
| 179 | func_list); |
| 180 | // If the search filter specifies a Compilation Unit, then we don't need to bother to look in plain |
| 181 | // symbols, since all the ones from a set compilation unit will have been found above already. |
| 182 | |
| 183 | if (num_functions == 0 && !filter_by_cu) |
| 184 | { |
| 185 | if (m_func_name_type_mask & (eFunctionNameTypeBase | eFunctionNameTypeFull | eFunctionNameTypeAuto)) |
Jason Molenda | bf41e19 | 2012-10-04 22:47:07 +0000 | [diff] [blame] | 186 | context.module_sp->FindSymbolsWithNameAndType (m_func_names[j], eSymbolTypeCode, sym_list); |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 187 | } |
Greg Clayton | d74270e | 2011-09-02 04:03:59 +0000 | [diff] [blame] | 188 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 189 | } |
| 190 | break; |
| 191 | case Breakpoint::Regexp: |
| 192 | if (context.module_sp) |
| 193 | { |
Jim Ingham | d6d4797 | 2011-09-23 00:54:11 +0000 | [diff] [blame] | 194 | if (!filter_by_cu) |
| 195 | context.module_sp->FindSymbolsMatchingRegExAndType (m_regex, eSymbolTypeCode, sym_list); |
Greg Clayton | 28d5fcc | 2011-01-27 06:44:37 +0000 | [diff] [blame] | 196 | context.module_sp->FindFunctions (m_regex, |
Sean Callanan | 302d78c | 2012-02-10 22:52:19 +0000 | [diff] [blame] | 197 | include_symbols, |
| 198 | include_inlines, |
Greg Clayton | 28d5fcc | 2011-01-27 06:44:37 +0000 | [diff] [blame] | 199 | append, |
| 200 | func_list); |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 201 | } |
| 202 | break; |
| 203 | case Breakpoint::Glob: |
| 204 | if (log) |
| 205 | log->Warning ("glob is not supported yet."); |
| 206 | break; |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 207 | } |
Jim Ingham | d6d4797 | 2011-09-23 00:54:11 +0000 | [diff] [blame] | 208 | |
| 209 | // If the filter specifies a Compilation Unit, remove the ones that don't pass at this point. |
| 210 | if (filter_by_cu) |
| 211 | { |
| 212 | uint32_t num_functions = func_list.GetSize(); |
| 213 | |
| 214 | for (size_t idx = 0; idx < num_functions; idx++) |
| 215 | { |
| 216 | SymbolContext sc; |
| 217 | func_list.GetContextAtIndex(idx, sc); |
| 218 | if (!sc.comp_unit || !filter.CompUnitPasses(*sc.comp_unit)) |
| 219 | { |
| 220 | func_list.RemoveContextAtIndex(idx); |
| 221 | num_functions--; |
| 222 | idx--; |
| 223 | } |
| 224 | } |
| 225 | } |
Jim Ingham | d6d4797 | 2011-09-23 00:54:11 +0000 | [diff] [blame] | 226 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 227 | // Remove any duplicates between the funcion list and the symbol list |
| 228 | if (func_list.GetSize()) |
| 229 | { |
| 230 | for (i = 0; i < func_list.GetSize(); i++) |
| 231 | { |
| 232 | if (func_list.GetContextAtIndex(i, sc) == false) |
| 233 | continue; |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 234 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 235 | if (sc.function == NULL) |
| 236 | continue; |
| 237 | uint32_t j = 0; |
| 238 | while (j < sym_list.GetSize()) |
| 239 | { |
| 240 | SymbolContext symbol_sc; |
| 241 | if (sym_list.GetContextAtIndex(j, symbol_sc)) |
| 242 | { |
Greg Clayton | 0c31d3d | 2012-03-07 21:03:09 +0000 | [diff] [blame] | 243 | if (symbol_sc.symbol && symbol_sc.symbol->ValueIsAddress()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 244 | { |
Greg Clayton | 0c31d3d | 2012-03-07 21:03:09 +0000 | [diff] [blame] | 245 | if (sc.function->GetAddressRange().GetBaseAddress() == symbol_sc.symbol->GetAddress()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 246 | { |
| 247 | sym_list.RemoveContextAtIndex(j); |
| 248 | continue; // Don't increment j |
| 249 | } |
| 250 | } |
| 251 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 252 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 253 | j++; |
| 254 | } |
| 255 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 256 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 257 | for (i = 0; i < func_list.GetSize(); i++) |
| 258 | { |
| 259 | if (func_list.GetContextAtIndex(i, sc)) |
| 260 | { |
Greg Clayton | feb6e56 | 2010-11-14 00:22:48 +0000 | [diff] [blame] | 261 | if (sc.block && sc.block->GetInlinedFunctionInfo()) |
| 262 | { |
| 263 | if (!sc.block->GetStartAddress(break_addr)) |
| 264 | break_addr.Clear(); |
| 265 | } |
| 266 | else if (sc.function) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 267 | { |
| 268 | break_addr = sc.function->GetAddressRange().GetBaseAddress(); |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 269 | if (m_skip_prologue) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 270 | { |
Greg Clayton | feb6e56 | 2010-11-14 00:22:48 +0000 | [diff] [blame] | 271 | if (break_addr.IsValid()) |
| 272 | { |
| 273 | const uint32_t prologue_byte_size = sc.function->GetPrologueByteSize(); |
| 274 | if (prologue_byte_size) |
| 275 | break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); |
| 276 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 277 | } |
Greg Clayton | feb6e56 | 2010-11-14 00:22:48 +0000 | [diff] [blame] | 278 | } |
| 279 | |
| 280 | if (break_addr.IsValid()) |
| 281 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 282 | if (filter.AddressPasses(break_addr)) |
| 283 | { |
| 284 | BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location)); |
| 285 | if (bp_loc_sp && new_location && !m_breakpoint->IsInternal()) |
| 286 | { |
| 287 | if (log) |
| 288 | { |
| 289 | StreamString s; |
| 290 | bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); |
| 291 | log->Printf ("Added location: %s\n", s.GetData()); |
| 292 | } |
| 293 | } |
| 294 | } |
| 295 | } |
| 296 | } |
| 297 | } |
| 298 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 299 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 300 | for (i = 0; i < sym_list.GetSize(); i++) |
| 301 | { |
| 302 | if (sym_list.GetContextAtIndex(i, sc)) |
| 303 | { |
Greg Clayton | 0c31d3d | 2012-03-07 21:03:09 +0000 | [diff] [blame] | 304 | if (sc.symbol && sc.symbol->ValueIsAddress()) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 305 | { |
Greg Clayton | 0c31d3d | 2012-03-07 21:03:09 +0000 | [diff] [blame] | 306 | break_addr = sc.symbol->GetAddress(); |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 307 | |
Greg Clayton | 7dd98df | 2011-07-12 17:06:17 +0000 | [diff] [blame] | 308 | if (m_skip_prologue) |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 309 | { |
| 310 | const uint32_t prologue_byte_size = sc.symbol->GetPrologueByteSize(); |
| 311 | if (prologue_byte_size) |
| 312 | break_addr.SetOffset(break_addr.GetOffset() + prologue_byte_size); |
| 313 | } |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 314 | |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 315 | if (filter.AddressPasses(break_addr)) |
| 316 | { |
| 317 | BreakpointLocationSP bp_loc_sp (m_breakpoint->AddLocation(break_addr, &new_location)); |
| 318 | if (bp_loc_sp && new_location && !m_breakpoint->IsInternal()) |
| 319 | { |
| 320 | StreamString s; |
| 321 | bp_loc_sp->GetDescription(&s, lldb::eDescriptionLevelVerbose); |
| 322 | if (log) |
| 323 | log->Printf ("Added location: %s\n", s.GetData()); |
| 324 | } |
| 325 | } |
| 326 | } |
| 327 | } |
| 328 | } |
| 329 | return Searcher::eCallbackReturnContinue; |
| 330 | } |
| 331 | |
| 332 | Searcher::Depth |
| 333 | BreakpointResolverName::GetDepth() |
| 334 | { |
| 335 | return Searcher::eDepthModule; |
| 336 | } |
| 337 | |
| 338 | void |
| 339 | BreakpointResolverName::GetDescription (Stream *s) |
| 340 | { |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 341 | if (m_match_type == Breakpoint::Regexp) |
Greg Clayton | 12bec71 | 2010-06-28 21:30:43 +0000 | [diff] [blame] | 342 | s->Printf("regex = '%s'", m_regex.GetText()); |
Greg Clayton | 48fbdf7 | 2010-10-12 04:29:14 +0000 | [diff] [blame] | 343 | else |
Jim Ingham | c105362 | 2012-03-03 02:05:11 +0000 | [diff] [blame] | 344 | { |
| 345 | size_t num_names = m_func_names.size(); |
| 346 | if (num_names == 1) |
| 347 | s->Printf("name = '%s'", m_func_names[0].AsCString()); |
| 348 | else |
| 349 | { |
| 350 | s->Printf("names = {"); |
| 351 | for (size_t i = 0; i < num_names - 1; i++) |
| 352 | { |
| 353 | s->Printf ("'%s', ", m_func_names[i].AsCString()); |
| 354 | } |
| 355 | s->Printf ("'%s'}", m_func_names[num_names - 1].AsCString()); |
| 356 | } |
| 357 | } |
Chris Lattner | 24943d2 | 2010-06-08 16:52:24 +0000 | [diff] [blame] | 358 | } |
| 359 | |
| 360 | void |
| 361 | BreakpointResolverName::Dump (Stream *s) const |
| 362 | { |
| 363 | |
| 364 | } |
| 365 | |