LLDB  mainline
CommandObjectSource.cpp
Go to the documentation of this file.
1 //===-- CommandObjectSource.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 "CommandObjectSource.h"
10 
11 #include "lldb/Core/Debugger.h"
13 #include "lldb/Core/Module.h"
14 #include "lldb/Core/ModuleSpec.h"
16 #include "lldb/Host/OptionParser.h"
22 #include "lldb/Symbol/Function.h"
23 #include "lldb/Symbol/Symbol.h"
25 #include "lldb/Target/StackFrame.h"
26 #include "lldb/Utility/FileSpec.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 
31 #pragma mark CommandObjectSourceInfo
32 // CommandObjectSourceInfo - debug line entries dumping command
33 #define LLDB_OPTIONS_source_info
34 #include "CommandOptions.inc"
35 
37  class CommandOptions : public Options {
38  public:
40 
41  ~CommandOptions() override = default;
42 
43  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
44  ExecutionContext *execution_context) override {
45  Status error;
46  const int short_option = GetDefinitions()[option_idx].short_option;
47  switch (short_option) {
48  case 'l':
49  if (option_arg.getAsInteger(0, start_line))
50  error.SetErrorStringWithFormat("invalid line number: '%s'",
51  option_arg.str().c_str());
52  break;
53 
54  case 'e':
55  if (option_arg.getAsInteger(0, end_line))
56  error.SetErrorStringWithFormat("invalid line number: '%s'",
57  option_arg.str().c_str());
58  break;
59 
60  case 'c':
61  if (option_arg.getAsInteger(0, num_lines))
62  error.SetErrorStringWithFormat("invalid line count: '%s'",
63  option_arg.str().c_str());
64  break;
65 
66  case 'f':
67  file_name = std::string(option_arg);
68  break;
69 
70  case 'n':
71  symbol_name = std::string(option_arg);
72  break;
73 
74  case 'a': {
75  address = OptionArgParser::ToAddress(execution_context, option_arg,
77  } break;
78  case 's':
79  modules.push_back(std::string(option_arg));
80  break;
81  default:
82  llvm_unreachable("Unimplemented option");
83  }
84 
85  return error;
86  }
87 
88  void OptionParsingStarting(ExecutionContext *execution_context) override {
89  file_spec.Clear();
90  file_name.clear();
91  symbol_name.clear();
92  address = LLDB_INVALID_ADDRESS;
93  start_line = 0;
94  end_line = 0;
95  num_lines = 0;
96  modules.clear();
97  }
98 
99  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
100  return llvm::makeArrayRef(g_source_info_options);
101  }
102 
103  // Instance variables to hold the values for command options.
111  std::vector<std::string> modules;
112  };
113 
114 public:
117  interpreter, "source info",
118  "Display source line information for the current target "
119  "process. Defaults to instruction pointer in current stack "
120  "frame.",
121  nullptr, eCommandRequiresTarget),
122  m_options() {}
123 
124  ~CommandObjectSourceInfo() override = default;
125 
126  Options *GetOptions() override { return &m_options; }
127 
128 protected:
129  // Dump the line entries in each symbol context. Return the number of entries
130  // found. If module_list is set, only dump lines contained in one of the
131  // modules. If file_spec is set, only dump lines in the file. If the
132  // start_line option was specified, don't print lines less than start_line.
133  // If the end_line option was specified, don't print lines greater than
134  // end_line. If the num_lines option was specified, dont print more than
135  // num_lines entries.
137  const SymbolContextList &sc_list,
138  const ModuleList &module_list,
139  const FileSpec &file_spec) {
140  uint32_t start_line = m_options.start_line;
141  uint32_t end_line = m_options.end_line;
142  uint32_t num_lines = m_options.num_lines;
143  Target *target = m_exe_ctx.GetTargetPtr();
144 
145  uint32_t num_matches = 0;
146  // Dump all the line entries for the file in the list.
147  ConstString last_module_file_name;
148  uint32_t num_scs = sc_list.GetSize();
149  for (uint32_t i = 0; i < num_scs; ++i) {
150  SymbolContext sc;
151  sc_list.GetContextAtIndex(i, sc);
152  if (sc.comp_unit) {
153  Module *module = sc.module_sp.get();
154  CompileUnit *cu = sc.comp_unit;
155  const LineEntry &line_entry = sc.line_entry;
156  assert(module && cu);
157 
158  // Are we looking for specific modules, files or lines?
159  if (module_list.GetSize() &&
160  module_list.GetIndexForModule(module) == LLDB_INVALID_INDEX32)
161  continue;
162  if (!FileSpec::Match(file_spec, line_entry.file))
163  continue;
164  if (start_line > 0 && line_entry.line < start_line)
165  continue;
166  if (end_line > 0 && line_entry.line > end_line)
167  continue;
168  if (num_lines > 0 && num_matches > num_lines)
169  continue;
170 
171  // Print a new header if the module changed.
172  ConstString module_file_name = module->GetFileSpec().GetFilename();
173  assert(module_file_name);
174  if (module_file_name != last_module_file_name) {
175  if (num_matches > 0)
176  strm << "\n\n";
177  strm << "Lines found in module `" << module_file_name << "\n";
178  }
179  // Dump the line entry.
180  line_entry.GetDescription(&strm, lldb::eDescriptionLevelBrief, cu,
181  target, /*show_address_only=*/false);
182  strm << "\n";
183  last_module_file_name = module_file_name;
184  num_matches++;
185  }
186  }
187  return num_matches;
188  }
189 
190  // Dump the requested line entries for the file in the compilation unit.
191  // Return the number of entries found. If module_list is set, only dump lines
192  // contained in one of the modules. If the start_line option was specified,
193  // don't print lines less than start_line. If the end_line option was
194  // specified, don't print lines greater than end_line. If the num_lines
195  // option was specified, dont print more than num_lines entries.
197  CompileUnit *cu, const FileSpec &file_spec) {
198  uint32_t start_line = m_options.start_line;
199  uint32_t end_line = m_options.end_line;
200  uint32_t num_lines = m_options.num_lines;
201  Target *target = m_exe_ctx.GetTargetPtr();
202 
203  uint32_t num_matches = 0;
204  assert(module);
205  if (cu) {
206  assert(file_spec.GetFilename().AsCString());
207  bool has_path = (file_spec.GetDirectory().AsCString() != nullptr);
208  const FileSpecList &cu_file_list = cu->GetSupportFiles();
209  size_t file_idx = cu_file_list.FindFileIndex(0, file_spec, has_path);
210  if (file_idx != UINT32_MAX) {
211  // Update the file to how it appears in the CU.
212  const FileSpec &cu_file_spec =
213  cu_file_list.GetFileSpecAtIndex(file_idx);
214 
215  // Dump all matching lines at or above start_line for the file in the
216  // CU.
217  ConstString file_spec_name = file_spec.GetFilename();
218  ConstString module_file_name = module->GetFileSpec().GetFilename();
219  bool cu_header_printed = false;
220  uint32_t line = start_line;
221  while (true) {
222  LineEntry line_entry;
223 
224  // Find the lowest index of a line entry with a line equal to or
225  // higher than 'line'.
226  uint32_t start_idx = 0;
227  start_idx = cu->FindLineEntry(start_idx, line, &cu_file_spec,
228  /*exact=*/false, &line_entry);
229  if (start_idx == UINT32_MAX)
230  // No more line entries for our file in this CU.
231  break;
232 
233  if (end_line > 0 && line_entry.line > end_line)
234  break;
235 
236  // Loop through to find any other entries for this line, dumping
237  // each.
238  line = line_entry.line;
239  do {
240  num_matches++;
241  if (num_lines > 0 && num_matches > num_lines)
242  break;
243  assert(cu_file_spec == line_entry.file);
244  if (!cu_header_printed) {
245  if (num_matches > 0)
246  strm << "\n\n";
247  strm << "Lines found for file " << file_spec_name
248  << " in compilation unit "
249  << cu->GetPrimaryFile().GetFilename() << " in `"
250  << module_file_name << "\n";
251  cu_header_printed = true;
252  }
253  line_entry.GetDescription(&strm, lldb::eDescriptionLevelBrief, cu,
254  target, /*show_address_only=*/false);
255  strm << "\n";
256 
257  // Anymore after this one?
258  start_idx++;
259  start_idx = cu->FindLineEntry(start_idx, line, &cu_file_spec,
260  /*exact=*/true, &line_entry);
261  } while (start_idx != UINT32_MAX);
262 
263  // Try the next higher line, starting over at start_idx 0.
264  line++;
265  }
266  }
267  }
268  return num_matches;
269  }
270 
271  // Dump the requested line entries for the file in the module. Return the
272  // number of entries found. If module_list is set, only dump lines contained
273  // in one of the modules. If the start_line option was specified, don't print
274  // lines less than start_line. If the end_line option was specified, don't
275  // print lines greater than end_line. If the num_lines option was specified,
276  // dont print more than num_lines entries.
278  const FileSpec &file_spec) {
279  uint32_t num_matches = 0;
280  if (module) {
281  // Look through all the compilation units (CUs) in this module for ones
282  // that contain lines of code from this source file.
283  for (size_t i = 0; i < module->GetNumCompileUnits(); i++) {
284  // Look for a matching source file in this CU.
285  CompUnitSP cu_sp(module->GetCompileUnitAtIndex(i));
286  if (cu_sp) {
287  num_matches +=
288  DumpFileLinesInCompUnit(strm, module, cu_sp.get(), file_spec);
289  }
290  }
291  }
292  return num_matches;
293  }
294 
295  // Given an address and a list of modules, append the symbol contexts of all
296  // line entries containing the address found in the modules and return the
297  // count of matches. If none is found, return an error in 'error_strm'.
298  size_t GetSymbolContextsForAddress(const ModuleList &module_list,
299  lldb::addr_t addr,
300  SymbolContextList &sc_list,
301  StreamString &error_strm) {
302  Address so_addr;
303  size_t num_matches = 0;
304  assert(module_list.GetSize() > 0);
305  Target *target = m_exe_ctx.GetTargetPtr();
306  if (target->GetSectionLoadList().IsEmpty()) {
307  // The target isn't loaded yet, we need to lookup the file address in all
308  // modules. Note: the module list option does not apply to addresses.
309  const size_t num_modules = module_list.GetSize();
310  for (size_t i = 0; i < num_modules; ++i) {
311  ModuleSP module_sp(module_list.GetModuleAtIndex(i));
312  if (!module_sp)
313  continue;
314  if (module_sp->ResolveFileAddress(addr, so_addr)) {
315  SymbolContext sc;
316  sc.Clear(true);
317  if (module_sp->ResolveSymbolContextForAddress(
318  so_addr, eSymbolContextEverything, sc) &
319  eSymbolContextLineEntry) {
320  sc_list.AppendIfUnique(sc, /*merge_symbol_into_function=*/false);
321  ++num_matches;
322  }
323  }
324  }
325  if (num_matches == 0)
326  error_strm.Printf("Source information for file address 0x%" PRIx64
327  " not found in any modules.\n",
328  addr);
329  } else {
330  // The target has some things loaded, resolve this address to a compile
331  // unit + file + line and display
332  if (target->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
333  ModuleSP module_sp(so_addr.GetModule());
334  // Check to make sure this module is in our list.
335  if (module_sp && module_list.GetIndexForModule(module_sp.get()) !=
337  SymbolContext sc;
338  sc.Clear(true);
339  if (module_sp->ResolveSymbolContextForAddress(
340  so_addr, eSymbolContextEverything, sc) &
341  eSymbolContextLineEntry) {
342  sc_list.AppendIfUnique(sc, /*merge_symbol_into_function=*/false);
343  ++num_matches;
344  } else {
345  StreamString addr_strm;
346  so_addr.Dump(&addr_strm, nullptr,
347  Address::DumpStyleModuleWithFileAddress);
348  error_strm.Printf(
349  "Address 0x%" PRIx64 " resolves to %s, but there is"
350  " no source information available for this address.\n",
351  addr, addr_strm.GetData());
352  }
353  } else {
354  StreamString addr_strm;
355  so_addr.Dump(&addr_strm, nullptr,
356  Address::DumpStyleModuleWithFileAddress);
357  error_strm.Printf("Address 0x%" PRIx64
358  " resolves to %s, but it cannot"
359  " be found in any modules.\n",
360  addr, addr_strm.GetData());
361  }
362  } else
363  error_strm.Printf("Unable to resolve address 0x%" PRIx64 ".\n", addr);
364  }
365  return num_matches;
366  }
367 
368  // Dump the line entries found in functions matching the name specified in
369  // the option.
371  SymbolContextList sc_list_funcs;
372  ConstString name(m_options.symbol_name.c_str());
373  SymbolContextList sc_list_lines;
374  Target *target = m_exe_ctx.GetTargetPtr();
375  uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
376 
377  // Note: module_list can't be const& because FindFunctionSymbols isn't
378  // const.
379  ModuleList module_list =
380  (m_module_list.GetSize() > 0) ? m_module_list : target->GetImages();
381  module_list.FindFunctions(name, eFunctionNameTypeAuto,
382  /*include_symbols=*/false,
383  /*include_inlines=*/true, sc_list_funcs);
384  size_t num_matches = sc_list_funcs.GetSize();
385 
386  if (!num_matches) {
387  // If we didn't find any functions with that name, try searching for
388  // symbols that line up exactly with function addresses.
389  SymbolContextList sc_list_symbols;
390  module_list.FindFunctionSymbols(name, eFunctionNameTypeAuto,
391  sc_list_symbols);
392  size_t num_symbol_matches = sc_list_symbols.GetSize();
393  for (size_t i = 0; i < num_symbol_matches; i++) {
394  SymbolContext sc;
395  sc_list_symbols.GetContextAtIndex(i, sc);
396  if (sc.symbol && sc.symbol->ValueIsAddress()) {
397  const Address &base_address = sc.symbol->GetAddressRef();
398  Function *function = base_address.CalculateSymbolContextFunction();
399  if (function) {
400  sc_list_funcs.Append(SymbolContext(function));
401  num_matches++;
402  }
403  }
404  }
405  }
406  if (num_matches == 0) {
407  result.AppendErrorWithFormat("Could not find function named \'%s\'.\n",
408  m_options.symbol_name.c_str());
409  return false;
410  }
411  for (size_t i = 0; i < num_matches; i++) {
412  SymbolContext sc;
413  sc_list_funcs.GetContextAtIndex(i, sc);
414  bool context_found_for_symbol = false;
415  // Loop through all the ranges in the function.
416  AddressRange range;
417  for (uint32_t r = 0;
418  sc.GetAddressRange(eSymbolContextEverything, r,
419  /*use_inline_block_range=*/true, range);
420  ++r) {
421  // Append the symbol contexts for each address in the range to
422  // sc_list_lines.
423  const Address &base_address = range.GetBaseAddress();
424  const addr_t size = range.GetByteSize();
425  lldb::addr_t start_addr = base_address.GetLoadAddress(target);
426  if (start_addr == LLDB_INVALID_ADDRESS)
427  start_addr = base_address.GetFileAddress();
428  lldb::addr_t end_addr = start_addr + size;
429  for (lldb::addr_t addr = start_addr; addr < end_addr;
430  addr += addr_byte_size) {
431  StreamString error_strm;
432  if (!GetSymbolContextsForAddress(module_list, addr, sc_list_lines,
433  error_strm))
434  result.AppendWarningWithFormat("in symbol '%s': %s",
435  sc.GetFunctionName().AsCString(),
436  error_strm.GetData());
437  else
438  context_found_for_symbol = true;
439  }
440  }
441  if (!context_found_for_symbol)
442  result.AppendWarningWithFormat("Unable to find line information"
443  " for matching symbol '%s'.\n",
444  sc.GetFunctionName().AsCString());
445  }
446  if (sc_list_lines.GetSize() == 0) {
447  result.AppendErrorWithFormat("No line information could be found"
448  " for any symbols matching '%s'.\n",
449  name.AsCString());
450  return false;
451  }
452  FileSpec file_spec;
453  if (!DumpLinesInSymbolContexts(result.GetOutputStream(), sc_list_lines,
454  module_list, file_spec)) {
455  result.AppendErrorWithFormat(
456  "Unable to dump line information for symbol '%s'.\n",
457  name.AsCString());
458  return false;
459  }
460  return true;
461  }
462 
463  // Dump the line entries found for the address specified in the option.
465  Target *target = m_exe_ctx.GetTargetPtr();
466  SymbolContextList sc_list;
467 
468  StreamString error_strm;
469  if (!GetSymbolContextsForAddress(target->GetImages(), m_options.address,
470  sc_list, error_strm)) {
471  result.AppendErrorWithFormat("%s.\n", error_strm.GetData());
472  return false;
473  }
474  ModuleList module_list;
475  FileSpec file_spec;
476  if (!DumpLinesInSymbolContexts(result.GetOutputStream(), sc_list,
477  module_list, file_spec)) {
478  result.AppendErrorWithFormat("No modules contain load address 0x%" PRIx64
479  ".\n",
480  m_options.address);
481  return false;
482  }
483  return true;
484  }
485 
486  // Dump the line entries found in the file specified in the option.
488  FileSpec file_spec(m_options.file_name);
489  const char *filename = m_options.file_name.c_str();
490  Target *target = m_exe_ctx.GetTargetPtr();
491  const ModuleList &module_list =
492  (m_module_list.GetSize() > 0) ? m_module_list : target->GetImages();
493 
494  bool displayed_something = false;
495  const size_t num_modules = module_list.GetSize();
496  for (uint32_t i = 0; i < num_modules; ++i) {
497  // Dump lines for this module.
498  Module *module = module_list.GetModulePointerAtIndex(i);
499  assert(module);
500  if (DumpFileLinesInModule(result.GetOutputStream(), module, file_spec))
501  displayed_something = true;
502  }
503  if (!displayed_something) {
504  result.AppendErrorWithFormat("No source filenames matched '%s'.\n",
505  filename);
506  return false;
507  }
508  return true;
509  }
510 
511  // Dump the line entries for the current frame.
513  StackFrame *cur_frame = m_exe_ctx.GetFramePtr();
514  if (cur_frame == nullptr) {
515  result.AppendError(
516  "No selected frame to use to find the default source.");
517  return false;
518  } else if (!cur_frame->HasDebugInformation()) {
519  result.AppendError("No debug info for the selected frame.");
520  return false;
521  } else {
522  const SymbolContext &sc =
523  cur_frame->GetSymbolContext(eSymbolContextLineEntry);
524  SymbolContextList sc_list;
525  sc_list.Append(sc);
526  ModuleList module_list;
527  FileSpec file_spec;
528  if (!DumpLinesInSymbolContexts(result.GetOutputStream(), sc_list,
529  module_list, file_spec)) {
530  result.AppendError(
531  "No source line info available for the selected frame.");
532  return false;
533  }
534  }
535  return true;
536  }
537 
538  bool DoExecute(Args &command, CommandReturnObject &result) override {
539  const size_t argc = command.GetArgumentCount();
540 
541  if (argc != 0) {
542  result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n",
543  GetCommandName().str().c_str());
545  return false;
546  }
547 
548  Target *target = m_exe_ctx.GetTargetPtr();
549  if (target == nullptr) {
550  target = GetDebugger().GetSelectedTarget().get();
551  if (target == nullptr) {
552  result.AppendError("invalid target, create a debug target using the "
553  "'target create' command.");
555  return false;
556  }
557  }
558 
559  uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
560  result.GetOutputStream().SetAddressByteSize(addr_byte_size);
561  result.GetErrorStream().SetAddressByteSize(addr_byte_size);
562 
563  // Collect the list of modules to search.
564  m_module_list.Clear();
565  if (!m_options.modules.empty()) {
566  for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
567  FileSpec module_file_spec(m_options.modules[i]);
568  if (module_file_spec) {
569  ModuleSpec module_spec(module_file_spec);
570  target->GetImages().FindModules(module_spec, m_module_list);
571  if (m_module_list.IsEmpty())
572  result.AppendWarningWithFormat("No module found for '%s'.\n",
573  m_options.modules[i].c_str());
574  }
575  }
576  if (!m_module_list.GetSize()) {
577  result.AppendError("No modules match the input.");
579  return false;
580  }
581  } else if (target->GetImages().GetSize() == 0) {
582  result.AppendError("The target has no associated executable images.");
584  return false;
585  }
586 
587  // Check the arguments to see what lines we should dump.
588  if (!m_options.symbol_name.empty()) {
589  // Print lines for symbol.
590  if (DumpLinesInFunctions(result))
592  else
594  } else if (m_options.address != LLDB_INVALID_ADDRESS) {
595  // Print lines for an address.
596  if (DumpLinesForAddress(result))
598  else
600  } else if (!m_options.file_name.empty()) {
601  // Dump lines for a file.
602  if (DumpLinesForFile(result))
604  else
606  } else {
607  // Dump the line for the current frame.
608  if (DumpLinesForFrame(result))
610  else
612  }
613  return result.Succeeded();
614  }
615 
618 };
619 
620 #pragma mark CommandObjectSourceList
621 // CommandObjectSourceList
622 #define LLDB_OPTIONS_source_list
623 #include "CommandOptions.inc"
624 
626  class CommandOptions : public Options {
627  public:
629 
630  ~CommandOptions() override = default;
631 
632  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
633  ExecutionContext *execution_context) override {
634  Status error;
635  const int short_option = GetDefinitions()[option_idx].short_option;
636  switch (short_option) {
637  case 'l':
638  if (option_arg.getAsInteger(0, start_line))
639  error.SetErrorStringWithFormat("invalid line number: '%s'",
640  option_arg.str().c_str());
641  break;
642 
643  case 'c':
644  if (option_arg.getAsInteger(0, num_lines))
645  error.SetErrorStringWithFormat("invalid line count: '%s'",
646  option_arg.str().c_str());
647  break;
648 
649  case 'f':
650  file_name = std::string(option_arg);
651  break;
652 
653  case 'n':
654  symbol_name = std::string(option_arg);
655  break;
656 
657  case 'a': {
658  address = OptionArgParser::ToAddress(execution_context, option_arg,
660  } break;
661  case 's':
662  modules.push_back(std::string(option_arg));
663  break;
664 
665  case 'b':
666  show_bp_locs = true;
667  break;
668  case 'r':
669  reverse = true;
670  break;
671  case 'y':
672  {
674  Status fcl_err = value.SetValueFromString(option_arg);
675  if (!fcl_err.Success()) {
676  error.SetErrorStringWithFormat(
677  "Invalid value for file:line specifier: %s",
678  fcl_err.AsCString());
679  } else {
680  file_name = value.GetFileSpec().GetPath();
681  start_line = value.GetLineNumber();
682  // I don't see anything useful to do with a column number, but I don't
683  // want to complain since someone may well have cut and pasted a
684  // listing from somewhere that included a column.
685  }
686  } break;
687  default:
688  llvm_unreachable("Unimplemented option");
689  }
690 
691  return error;
692  }
693 
694  void OptionParsingStarting(ExecutionContext *execution_context) override {
695  file_spec.Clear();
696  file_name.clear();
697  symbol_name.clear();
698  address = LLDB_INVALID_ADDRESS;
699  start_line = 0;
700  num_lines = 0;
701  show_bp_locs = false;
702  reverse = false;
703  modules.clear();
704  }
705 
706  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
707  return llvm::makeArrayRef(g_source_list_options);
708  }
709 
710  // Instance variables to hold the values for command options.
717  std::vector<std::string> modules;
719  bool reverse;
720  };
721 
722 public:
724  : CommandObjectParsed(interpreter, "source list",
725  "Display source code for the current target "
726  "process as specified by options.",
727  nullptr, eCommandRequiresTarget),
728  m_options() {}
729 
730  ~CommandObjectSourceList() override = default;
731 
732  Options *GetOptions() override { return &m_options; }
733 
734  const char *GetRepeatCommand(Args &current_command_args,
735  uint32_t index) override {
736  // This is kind of gross, but the command hasn't been parsed yet so we
737  // can't look at the option values for this invocation... I have to scan
738  // the arguments directly.
739  auto iter =
740  llvm::find_if(current_command_args, [](const Args::ArgEntry &e) {
741  return e.ref() == "-r" || e.ref() == "--reverse";
742  });
743  if (iter == current_command_args.end())
744  return m_cmd_name.c_str();
745 
746  if (m_reverse_name.empty()) {
747  m_reverse_name = m_cmd_name;
748  m_reverse_name.append(" -r");
749  }
750  return m_reverse_name.c_str();
751  }
752 
753 protected:
754  struct SourceInfo {
755  ConstString function;
757 
758  SourceInfo(ConstString name, const LineEntry &line_entry)
759  : function(name), line_entry(line_entry) {}
760 
761  SourceInfo() : function(), line_entry() {}
762 
763  bool IsValid() const { return (bool)function && line_entry.IsValid(); }
764 
765  bool operator==(const SourceInfo &rhs) const {
766  return function == rhs.function &&
767  line_entry.original_file == rhs.line_entry.original_file &&
768  line_entry.line == rhs.line_entry.line;
769  }
770 
771  bool operator!=(const SourceInfo &rhs) const {
772  return function != rhs.function ||
773  line_entry.original_file != rhs.line_entry.original_file ||
774  line_entry.line != rhs.line_entry.line;
775  }
776 
777  bool operator<(const SourceInfo &rhs) const {
778  if (function.GetCString() < rhs.function.GetCString())
779  return true;
780  if (line_entry.file.GetDirectory().GetCString() <
782  return true;
783  if (line_entry.file.GetFilename().GetCString() <
785  return true;
786  if (line_entry.line < rhs.line_entry.line)
787  return true;
788  return false;
789  }
790  };
791 
792  size_t DisplayFunctionSource(const SymbolContext &sc, SourceInfo &source_info,
793  CommandReturnObject &result) {
794  if (!source_info.IsValid()) {
795  source_info.function = sc.GetFunctionName();
796  source_info.line_entry = sc.GetFunctionStartLineEntry();
797  }
798 
799  if (sc.function) {
800  Target *target = m_exe_ctx.GetTargetPtr();
801 
802  FileSpec start_file;
803  uint32_t start_line;
804  uint32_t end_line;
805  FileSpec end_file;
806 
807  if (sc.block == nullptr) {
808  // Not an inlined function
809  sc.function->GetStartLineSourceInfo(start_file, start_line);
810  if (start_line == 0) {
811  result.AppendErrorWithFormat("Could not find line information for "
812  "start of function: \"%s\".\n",
813  source_info.function.GetCString());
815  return 0;
816  }
817  sc.function->GetEndLineSourceInfo(end_file, end_line);
818  } else {
819  // We have an inlined function
820  start_file = source_info.line_entry.file;
821  start_line = source_info.line_entry.line;
822  end_line = start_line + m_options.num_lines;
823  }
824 
825  // This is a little hacky, but the first line table entry for a function
826  // points to the "{" that starts the function block. It would be nice to
827  // actually get the function declaration in there too. So back up a bit,
828  // but not further than what you're going to display.
829  uint32_t extra_lines;
830  if (m_options.num_lines >= 10)
831  extra_lines = 5;
832  else
833  extra_lines = m_options.num_lines / 2;
834  uint32_t line_no;
835  if (start_line <= extra_lines)
836  line_no = 1;
837  else
838  line_no = start_line - extra_lines;
839 
840  // For fun, if the function is shorter than the number of lines we're
841  // supposed to display, only display the function...
842  if (end_line != 0) {
843  if (m_options.num_lines > end_line - line_no)
844  m_options.num_lines = end_line - line_no + extra_lines;
845  }
846 
847  m_breakpoint_locations.Clear();
848 
849  if (m_options.show_bp_locs) {
850  const bool show_inlines = true;
851  m_breakpoint_locations.Reset(start_file, 0, show_inlines);
852  SearchFilterForUnconstrainedSearches target_search_filter(
853  m_exe_ctx.GetTargetSP());
854  target_search_filter.Search(m_breakpoint_locations);
855  }
856 
857  result.AppendMessageWithFormat("File: %s\n",
858  start_file.GetPath().c_str());
859  // We don't care about the column here.
860  const uint32_t column = 0;
862  start_file, line_no, column, 0, m_options.num_lines, "",
863  &result.GetOutputStream(), GetBreakpointLocations());
864  } else {
865  result.AppendErrorWithFormat(
866  "Could not find function info for: \"%s\".\n",
867  m_options.symbol_name.c_str());
868  }
869  return 0;
870  }
871 
872  // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols
873  // functions "take a possibly empty vector of strings which are names of
874  // modules, and run the two search functions on the subset of the full module
875  // list that matches the strings in the input vector". If we wanted to put
876  // these somewhere, there should probably be a module-filter-list that can be
877  // passed to the various ModuleList::Find* calls, which would either be a
878  // vector of string names or a ModuleSpecList.
880  SymbolContextList &sc_list) {
881  // Displaying the source for a symbol:
882  bool include_inlines = true;
883  bool include_symbols = false;
884 
885  if (m_options.num_lines == 0)
886  m_options.num_lines = 10;
887 
888  const size_t num_modules = m_options.modules.size();
889  if (num_modules > 0) {
890  ModuleList matching_modules;
891  for (size_t i = 0; i < num_modules; ++i) {
892  FileSpec module_file_spec(m_options.modules[i]);
893  if (module_file_spec) {
894  ModuleSpec module_spec(module_file_spec);
895  matching_modules.Clear();
896  target->GetImages().FindModules(module_spec, matching_modules);
897  matching_modules.FindFunctions(name, eFunctionNameTypeAuto,
898  include_symbols, include_inlines,
899  sc_list);
900  }
901  }
902  } else {
903  target->GetImages().FindFunctions(name, eFunctionNameTypeAuto,
904  include_symbols, include_inlines,
905  sc_list);
906  }
907  }
908 
910  SymbolContextList &sc_list) {
911  const size_t num_modules = m_options.modules.size();
912  if (num_modules > 0) {
913  ModuleList matching_modules;
914  for (size_t i = 0; i < num_modules; ++i) {
915  FileSpec module_file_spec(m_options.modules[i]);
916  if (module_file_spec) {
917  ModuleSpec module_spec(module_file_spec);
918  matching_modules.Clear();
919  target->GetImages().FindModules(module_spec, matching_modules);
920  matching_modules.FindFunctionSymbols(name, eFunctionNameTypeAuto,
921  sc_list);
922  }
923  }
924  } else {
925  target->GetImages().FindFunctionSymbols(name, eFunctionNameTypeAuto,
926  sc_list);
927  }
928  }
929 
930  bool DoExecute(Args &command, CommandReturnObject &result) override {
931  const size_t argc = command.GetArgumentCount();
932 
933  if (argc != 0) {
934  result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n",
935  GetCommandName().str().c_str());
937  return false;
938  }
939 
940  Target *target = m_exe_ctx.GetTargetPtr();
941 
942  if (!m_options.symbol_name.empty()) {
943  SymbolContextList sc_list;
944  ConstString name(m_options.symbol_name.c_str());
945 
946  // Displaying the source for a symbol. Search for function named name.
947  FindMatchingFunctions(target, name, sc_list);
948  size_t num_matches = sc_list.GetSize();
949  if (!num_matches) {
950  // If we didn't find any functions with that name, try searching for
951  // symbols that line up exactly with function addresses.
952  SymbolContextList sc_list_symbols;
953  FindMatchingFunctionSymbols(target, name, sc_list_symbols);
954  size_t num_symbol_matches = sc_list_symbols.GetSize();
955 
956  for (size_t i = 0; i < num_symbol_matches; i++) {
957  SymbolContext sc;
958  sc_list_symbols.GetContextAtIndex(i, sc);
959  if (sc.symbol && sc.symbol->ValueIsAddress()) {
960  const Address &base_address = sc.symbol->GetAddressRef();
961  Function *function = base_address.CalculateSymbolContextFunction();
962  if (function) {
963  sc_list.Append(SymbolContext(function));
964  num_matches++;
965  break;
966  }
967  }
968  }
969  }
970 
971  if (num_matches == 0) {
972  result.AppendErrorWithFormat("Could not find function named: \"%s\".\n",
973  m_options.symbol_name.c_str());
975  return false;
976  }
977 
978  if (num_matches > 1) {
979  std::set<SourceInfo> source_match_set;
980 
981  bool displayed_something = false;
982  for (size_t i = 0; i < num_matches; i++) {
983  SymbolContext sc;
984  sc_list.GetContextAtIndex(i, sc);
985  SourceInfo source_info(sc.GetFunctionName(),
987 
988  if (source_info.IsValid()) {
989  if (source_match_set.find(source_info) == source_match_set.end()) {
990  source_match_set.insert(source_info);
991  if (DisplayFunctionSource(sc, source_info, result))
992  displayed_something = true;
993  }
994  }
995  }
996 
997  if (displayed_something)
999  else
1001  } else {
1002  SymbolContext sc;
1003  sc_list.GetContextAtIndex(0, sc);
1004  SourceInfo source_info;
1005 
1006  if (DisplayFunctionSource(sc, source_info, result)) {
1008  } else {
1010  }
1011  }
1012  return result.Succeeded();
1013  } else if (m_options.address != LLDB_INVALID_ADDRESS) {
1014  Address so_addr;
1015  StreamString error_strm;
1016  SymbolContextList sc_list;
1017 
1018  if (target->GetSectionLoadList().IsEmpty()) {
1019  // The target isn't loaded yet, we need to lookup the file address in
1020  // all modules
1021  const ModuleList &module_list = target->GetImages();
1022  const size_t num_modules = module_list.GetSize();
1023  for (size_t i = 0; i < num_modules; ++i) {
1024  ModuleSP module_sp(module_list.GetModuleAtIndex(i));
1025  if (module_sp &&
1026  module_sp->ResolveFileAddress(m_options.address, so_addr)) {
1027  SymbolContext sc;
1028  sc.Clear(true);
1029  if (module_sp->ResolveSymbolContextForAddress(
1030  so_addr, eSymbolContextEverything, sc) &
1031  eSymbolContextLineEntry)
1032  sc_list.Append(sc);
1033  }
1034  }
1035 
1036  if (sc_list.GetSize() == 0) {
1037  result.AppendErrorWithFormat(
1038  "no modules have source information for file address 0x%" PRIx64
1039  ".\n",
1040  m_options.address);
1042  return false;
1043  }
1044  } else {
1045  // The target has some things loaded, resolve this address to a compile
1046  // unit + file + line and display
1047  if (target->GetSectionLoadList().ResolveLoadAddress(m_options.address,
1048  so_addr)) {
1049  ModuleSP module_sp(so_addr.GetModule());
1050  if (module_sp) {
1051  SymbolContext sc;
1052  sc.Clear(true);
1053  if (module_sp->ResolveSymbolContextForAddress(
1054  so_addr, eSymbolContextEverything, sc) &
1055  eSymbolContextLineEntry) {
1056  sc_list.Append(sc);
1057  } else {
1058  so_addr.Dump(&error_strm, nullptr,
1059  Address::DumpStyleModuleWithFileAddress);
1060  result.AppendErrorWithFormat("address resolves to %s, but there "
1061  "is no line table information "
1062  "available for this address.\n",
1063  error_strm.GetData());
1065  return false;
1066  }
1067  }
1068  }
1069 
1070  if (sc_list.GetSize() == 0) {
1071  result.AppendErrorWithFormat(
1072  "no modules contain load address 0x%" PRIx64 ".\n",
1073  m_options.address);
1075  return false;
1076  }
1077  }
1078  uint32_t num_matches = sc_list.GetSize();
1079  for (uint32_t i = 0; i < num_matches; ++i) {
1080  SymbolContext sc;
1081  sc_list.GetContextAtIndex(i, sc);
1082  if (sc.comp_unit) {
1083  if (m_options.show_bp_locs) {
1084  m_breakpoint_locations.Clear();
1085  const bool show_inlines = true;
1086  m_breakpoint_locations.Reset(sc.comp_unit->GetPrimaryFile(), 0,
1087  show_inlines);
1088  SearchFilterForUnconstrainedSearches target_search_filter(
1089  target->shared_from_this());
1090  target_search_filter.Search(m_breakpoint_locations);
1091  }
1092 
1093  bool show_fullpaths = true;
1094  bool show_module = true;
1095  bool show_inlined_frames = true;
1096  const bool show_function_arguments = true;
1097  const bool show_function_name = true;
1098  sc.DumpStopContext(&result.GetOutputStream(),
1099  m_exe_ctx.GetBestExecutionContextScope(),
1101  show_fullpaths, show_module, show_inlined_frames,
1102  show_function_arguments, show_function_name);
1103  result.GetOutputStream().EOL();
1104 
1105  if (m_options.num_lines == 0)
1106  m_options.num_lines = 10;
1107 
1108  size_t lines_to_back_up =
1109  m_options.num_lines >= 10 ? 5 : m_options.num_lines / 2;
1110 
1111  const uint32_t column =
1112  (GetDebugger().GetStopShowColumn() != eStopShowColumnNone)
1113  ? sc.line_entry.column
1114  : 0;
1116  sc.comp_unit->GetPrimaryFile(), sc.line_entry.line, column,
1117  lines_to_back_up, m_options.num_lines - lines_to_back_up, "->",
1118  &result.GetOutputStream(), GetBreakpointLocations());
1120  }
1121  }
1122  } else if (m_options.file_name.empty()) {
1123  // Last valid source manager context, or the current frame if no valid
1124  // last context in source manager. One little trick here, if you type the
1125  // exact same list command twice in a row, it is more likely because you
1126  // typed it once, then typed it again
1127  if (m_options.start_line == 0) {
1129  &result.GetOutputStream(), m_options.num_lines,
1130  m_options.reverse, GetBreakpointLocations())) {
1132  }
1133  } else {
1134  if (m_options.num_lines == 0)
1135  m_options.num_lines = 10;
1136 
1137  if (m_options.show_bp_locs) {
1138  SourceManager::FileSP last_file_sp(
1139  target->GetSourceManager().GetLastFile());
1140  if (last_file_sp) {
1141  const bool show_inlines = true;
1142  m_breakpoint_locations.Reset(last_file_sp->GetFileSpec(), 0,
1143  show_inlines);
1144  SearchFilterForUnconstrainedSearches target_search_filter(
1145  target->shared_from_this());
1146  target_search_filter.Search(m_breakpoint_locations);
1147  }
1148  } else
1149  m_breakpoint_locations.Clear();
1150 
1151  const uint32_t column = 0;
1152  if (target->GetSourceManager()
1154  m_options.start_line, // Line to display
1155  m_options.num_lines, // Lines after line to
1156  UINT32_MAX, // Don't mark "line"
1157  column,
1158  "", // Don't mark "line"
1159  &result.GetOutputStream(), GetBreakpointLocations())) {
1161  }
1162  }
1163  } else {
1164  const char *filename = m_options.file_name.c_str();
1165 
1166  bool check_inlines = false;
1167  SymbolContextList sc_list;
1168  size_t num_matches = 0;
1169 
1170  if (!m_options.modules.empty()) {
1171  ModuleList matching_modules;
1172  for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
1173  FileSpec module_file_spec(m_options.modules[i]);
1174  if (module_file_spec) {
1175  ModuleSpec module_spec(module_file_spec);
1176  matching_modules.Clear();
1177  target->GetImages().FindModules(module_spec, matching_modules);
1178  num_matches += matching_modules.ResolveSymbolContextForFilePath(
1179  filename, 0, check_inlines,
1180  SymbolContextItem(eSymbolContextModule |
1181  eSymbolContextCompUnit),
1182  sc_list);
1183  }
1184  }
1185  } else {
1186  num_matches = target->GetImages().ResolveSymbolContextForFilePath(
1187  filename, 0, check_inlines,
1188  eSymbolContextModule | eSymbolContextCompUnit, sc_list);
1189  }
1190 
1191  if (num_matches == 0) {
1192  result.AppendErrorWithFormat("Could not find source file \"%s\".\n",
1193  m_options.file_name.c_str());
1195  return false;
1196  }
1197 
1198  if (num_matches > 1) {
1199  bool got_multiple = false;
1200  CompileUnit *test_cu = nullptr;
1201 
1202  for (unsigned i = 0; i < num_matches; i++) {
1203  SymbolContext sc;
1204  sc_list.GetContextAtIndex(i, sc);
1205  if (sc.comp_unit) {
1206  if (test_cu) {
1207  if (test_cu != sc.comp_unit)
1208  got_multiple = true;
1209  break;
1210  } else
1211  test_cu = sc.comp_unit;
1212  }
1213  }
1214  if (got_multiple) {
1215  result.AppendErrorWithFormat(
1216  "Multiple source files found matching: \"%s.\"\n",
1217  m_options.file_name.c_str());
1219  return false;
1220  }
1221  }
1222 
1223  SymbolContext sc;
1224  if (sc_list.GetContextAtIndex(0, sc)) {
1225  if (sc.comp_unit) {
1226  if (m_options.show_bp_locs) {
1227  const bool show_inlines = true;
1228  m_breakpoint_locations.Reset(sc.comp_unit->GetPrimaryFile(), 0,
1229  show_inlines);
1230  SearchFilterForUnconstrainedSearches target_search_filter(
1231  target->shared_from_this());
1232  target_search_filter.Search(m_breakpoint_locations);
1233  } else
1234  m_breakpoint_locations.Clear();
1235 
1236  if (m_options.num_lines == 0)
1237  m_options.num_lines = 10;
1238  const uint32_t column = 0;
1240  sc.comp_unit->GetPrimaryFile(), m_options.start_line, column, 0,
1241  m_options.num_lines, "", &result.GetOutputStream(),
1242  GetBreakpointLocations());
1243 
1245  } else {
1246  result.AppendErrorWithFormat("No comp unit found for: \"%s.\"\n",
1247  m_options.file_name.c_str());
1249  return false;
1250  }
1251  }
1252  }
1253  return result.Succeeded();
1254  }
1255 
1257  if (m_breakpoint_locations.GetFileLineMatches().GetSize() > 0)
1258  return &m_breakpoint_locations.GetFileLineMatches();
1259  return nullptr;
1260  }
1261 
1265 };
1266 
1267 #pragma mark CommandObjectMultiwordSource
1268 // CommandObjectMultiwordSource
1269 
1270 CommandObjectMultiwordSource::CommandObjectMultiwordSource(
1271  CommandInterpreter &interpreter)
1272  : CommandObjectMultiword(interpreter, "source",
1273  "Commands for examining "
1274  "source code described by "
1275  "debug information for the "
1276  "current target process.",
1277  "source <subcommand> [<subcommand-options>]") {
1278  LoadSubCommand("info",
1279  CommandObjectSP(new CommandObjectSourceInfo(interpreter)));
1280  LoadSubCommand("list",
1281  CommandObjectSP(new CommandObjectSourceList(interpreter)));
1282 }
1283 
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::CommandObjectParsed
Definition: CommandObject.h:378
CommandObjectSourceInfo::CommandOptions::symbol_name
std::string symbol_name
Definition: CommandObjectSource.cpp:106
CommandObjectSourceList::CommandOptions::address
lldb::addr_t address
Definition: CommandObjectSource.cpp:714
CommandObjectSourceInfo::DumpLinesForFrame
bool DumpLinesForFrame(CommandReturnObject &result)
Definition: CommandObjectSource.cpp:512
lldb_private::SymbolContext::block
Block * block
The Block for a given query.
Definition: SymbolContext.h:321
CommandObjectSourceList::CommandOptions::SetOptionValue
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Definition: CommandObjectSource.cpp:632
lldb_private::ExecutionContext
Definition: ExecutionContext.h:291
lldb_private::SymbolContext::comp_unit
CompileUnit * comp_unit
The CompileUnit for a given query.
Definition: SymbolContext.h:319
lldb_private::Args::ArgEntry
Definition: Args.h:35
lldb_private::CompileUnit::GetSupportFiles
const FileSpecList & GetSupportFiles()
Get the compile unit's support file list.
Definition: CompileUnit.cpp:372
lldb_private::LineEntry::file
FileSpec file
The source file, possibly mapped by the target.source-map setting.
Definition: LineEntry.h:140
CommandObjectSourceList::DisplayFunctionSource
size_t DisplayFunctionSource(const SymbolContext &sc, SourceInfo &source_info, CommandReturnObject &result)
Definition: CommandObjectSource.cpp:792
CommandObjectSourceInfo::CommandOptions::file_name
std::string file_name
Definition: CommandObjectSource.cpp:105
CommandObjectSourceInfo::CommandOptions::GetDefinitions
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Definition: CommandObjectSource.cpp:99
CommandObjectSourceList::CommandOptions::symbol_name
std::string symbol_name
Definition: CommandObjectSource.cpp:713
CompileUnit.h
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:47
ModuleSpec.h
lldb_private::Address::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:835
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:118
lldb_private::SymbolContext::GetAddressRange
bool GetAddressRange(uint32_t scope, uint32_t range_idx, bool use_inline_block_range, AddressRange &range) const
Get the address range contained within a symbol context.
Definition: SymbolContext.cpp:382
lldb_private::SymbolContextList::Append
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Definition: SymbolContext.cpp:1193
lldb_private::ModuleList::GetIndexForModule
size_t GetIndexForModule(const Module *module) const
Definition: ModuleList.cpp:687
CommandObjectSourceInfo
Definition: CommandObjectSource.cpp:36
CommandObjectSourceList::CommandOptions::show_bp_locs
bool show_bp_locs
Definition: CommandObjectSource.cpp:718
lldb_private::ModuleList::GetModulePointerAtIndex
Module * GetModulePointerAtIndex(size_t idx) const
Get the module pointer for the module at index idx.
Definition: ModuleList.cpp:347
CommandObjectSourceInfo::m_module_list
ModuleList m_module_list
Definition: CommandObjectSource.cpp:617
lldb_private::AddressRange::GetByteSize
lldb::addr_t GetByteSize() const
Get accessor for the byte size of this range.
Definition: AddressRange.h:221
Module.h
CommandObjectSourceInfo::DoExecute
bool DoExecute(Args &command, CommandReturnObject &result) override
Definition: CommandObjectSource.cpp:538
CommandObjectSourceInfo::CommandOptions::CommandOptions
CommandOptions()
Definition: CommandObjectSource.cpp:39
CommandObjectSourceList::FindMatchingFunctionSymbols
void FindMatchingFunctionSymbols(Target *target, ConstString name, SymbolContextList &sc_list)
Definition: CommandObjectSource.cpp:909
SourceManager.h
lldb_private::SymbolContextList
Definition: SymbolContext.h:378
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1267
lldb_private::Module
Definition: Module.h:75
OptionArgParser.h
SectionLoadList.h
CommandObjectSourceInfo::DumpFileLinesInModule
uint32_t DumpFileLinesInModule(Stream &strm, Module *module, const FileSpec &file_spec)
Definition: CommandObjectSource.cpp:277
lldb_private::ConstString::AsCString
const char * AsCString(const char *value_if_empty=nullptr) const
Get the string value as a C string.
Definition: ConstString.h:193
CommandObjectSourceList::CommandOptions::file_name
std::string file_name
Definition: CommandObjectSource.cpp:712
StackFrame.h
lldb_private::SourceManager::DisplaySourceLinesWithLineNumbers
size_t DisplaySourceLinesWithLineNumbers(const FileSpec &file, uint32_t line, uint32_t column, uint32_t context_before, uint32_t context_after, const char *current_line_cstr, Stream *s, const SymbolContextList *bp_locs=nullptr)
Definition: SourceManager.cpp:242
lldb_private::SearchFilter::Search
virtual void Search(Searcher &searcher)
Call this method to do the search using the Searcher.
Definition: SearchFilter.cpp:204
CommandObjectSourceList::SourceInfo::SourceInfo
SourceInfo(ConstString name, const LineEntry &line_entry)
Definition: CommandObjectSource.cpp:758
CommandObjectSourceInfo::GetSymbolContextsForAddress
size_t GetSymbolContextsForAddress(const ModuleList &module_list, lldb::addr_t addr, SymbolContextList &sc_list, StreamString &error_strm)
Definition: CommandObjectSource.cpp:298
lldb_private::Stream
Definition: Stream.h:28
lldb_private::Args
Definition: Args.h:33
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
CommandObjectSourceInfo::DumpLinesInFunctions
bool DumpLinesInFunctions(CommandReturnObject &result)
Definition: CommandObjectSource.cpp:370
lldb_private::Args::ArgEntry::ref
llvm::StringRef ref() const
Definition: Args.h:50
CommandReturnObject.h
CommandObjectSourceList::m_breakpoint_locations
FileLineResolver m_breakpoint_locations
Definition: CommandObjectSource.cpp:1263
CommandObjectSourceInfo::DumpFileLinesInCompUnit
uint32_t DumpFileLinesInCompUnit(Stream &strm, Module *module, CompileUnit *cu, const FileSpec &file_spec)
Definition: CommandObjectSource.cpp:196
Debugger.h
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:447
lldb_private::StackFrame::HasDebugInformation
bool HasDebugInformation()
Determine whether this StackFrame has debug information available or not.
Definition: StackFrame.cpp:1133
lldb_private::ModuleList::Clear
void Clear()
Clear the object's state.
Definition: ModuleList.cpp:336
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:921
CommandObjectSourceList::CommandOptions::start_line
uint32_t start_line
Definition: CommandObjectSource.cpp:715
lldb_private::SourceManager::DisplaySourceLinesWithLineNumbersUsingLastFile
size_t DisplaySourceLinesWithLineNumbersUsingLastFile(uint32_t start_line, uint32_t count, uint32_t curr_line, uint32_t column, const char *current_line_cstr, Stream *s, const SymbolContextList *bp_locs=nullptr)
Definition: SourceManager.cpp:153
lldb_private::FileLineResolver
Definition: FileLineResolver.h:27
lldb_private::LineEntry::GetDescription
bool GetDescription(Stream *s, lldb::DescriptionLevel level, CompileUnit *cu, Target *target, bool show_address_only) const
Definition: LineEntry.cpp:106
lldb_private::CompileUnit
Definition: CompileUnit.h:38
CommandObjectSourceList::SourceInfo::function
ConstString function
Definition: CommandObjectSource.cpp:755
CommandObjectSourceInfo::DumpLinesForFile
bool DumpLinesForFile(CommandReturnObject &result)
Definition: CommandObjectSource.cpp:487
CommandObjectSourceList::SourceInfo::operator!=
bool operator!=(const SourceInfo &rhs) const
Definition: CommandObjectSource.cpp:771
lldb_private::OptionValueFileColonLine::GetLineNumber
uint32_t GetLineNumber()
Definition: OptionValueFileColonLine.h:46
lldb_private::Module::GetFileSpec
const FileSpec & GetFileSpec() const
Get const accessor for the module file specification.
Definition: Module.h:465
lldb_private::FileSpec
Definition: FileSpec.h:56
CommandObjectSourceList::CommandOptions::OptionParsingStarting
void OptionParsingStarting(ExecutionContext *execution_context) override
Definition: CommandObjectSource.cpp:694
lldb_private::CommandObjectMultiword
Definition: CommandObjectMultiword.h:19
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
Options.h
lldb_private::SymbolContext::symbol
Symbol * symbol
The Symbol for a given query.
Definition: SymbolContext.h:323
lldb_private::Status::Success
bool Success() const
Test for success condition.
Definition: Status.cpp:288
lldb_private::ModuleList::GetSize
size_t GetSize() const
Gets the size of the module list.
Definition: ModuleList.cpp:596
lldb_private::Function
Definition: Function.h:413
lldb_private::Options
Definition: Options.h:57
lldb_private::SymbolContext::DumpStopContext
bool DumpStopContext(Stream *s, ExecutionContextScope *exe_scope, const Address &so_addr, bool show_fullpaths, bool show_module, bool show_inlined_frames, bool show_function_arguments, bool show_function_name) const
Dump the stop context in this object to a Stream.
Definition: SymbolContext.cpp:70
lldb_private::ModuleList
Definition: ModuleList.h:71
CommandObjectSourceList::SourceInfo::SourceInfo
SourceInfo()
Definition: CommandObjectSource.cpp:761
FileLineResolver.h
lldb_private::CommandObjectMultiword::LoadSubCommand
bool LoadSubCommand(llvm::StringRef cmd_name, const lldb::CommandObjectSP &command_obj) override
Definition: CommandObjectMultiword.cpp:68
lldb_private::SymbolContext::GetFunctionStartLineEntry
LineEntry GetFunctionStartLineEntry() const
Get the line entry that corresponds to the function.
Definition: SymbolContext.cpp:677
lldb_private::CommandReturnObject::SetStatus
void SetStatus(lldb::ReturnStatus status)
Definition: CommandReturnObject.cpp:131
CommandObjectSourceInfo::CommandOptions::address
lldb::addr_t address
Definition: CommandObjectSource.cpp:107
lldb_private::ModuleList::ResolveSymbolContextForFilePath
uint32_t ResolveSymbolContextForFilePath(const char *file_path, uint32_t line, bool check_inlines, lldb::SymbolContextItem resolve_scope, SymbolContextList &sc_list) const
Resolve items in the symbol context for a given file and line. (const char
Definition: ModuleList.cpp:666
lldb_private::StreamString::GetData
const char * GetData() const
Definition: StreamString.h:43
lldb_private::SymbolContext::function
Function * function
The Function for a given query.
Definition: SymbolContext.h:320
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:290
CommandObjectSourceInfo::CommandOptions::start_line
uint32_t start_line
Definition: CommandObjectSource.cpp:108
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::CommandReturnObject::GetOutputStream
Stream & GetOutputStream()
Definition: CommandReturnObject.h:45
lldb_private::SymbolContextList::GetSize
uint32_t GetSize() const
Get accessor for a symbol context list size.
Definition: SymbolContext.cpp:1283
lldb_private::ConstString
Definition: ConstString.h:40
lldb_private::StreamString
Definition: StreamString.h:23
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::SymbolContext::GetFunctionName
ConstString GetFunctionName(Mangled::NamePreference preference=Mangled::ePreferDemangled) const
Find a name of the innermost function for the symbol context.
Definition: SymbolContext.cpp:656
CommandObjectSourceList::CommandOptions::file_spec
FileSpec file_spec
Definition: CommandObjectSource.cpp:711
CommandObjectSourceList::CommandOptions::CommandOptions
CommandOptions()
Definition: CommandObjectSource.cpp:628
CommandObjectSourceList::GetOptions
Options * GetOptions() override
Definition: CommandObjectSource.cpp:732
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:221
lldb::eStopShowColumnNone
@ eStopShowColumnNone
Definition: lldb-enumerations.h:504
CommandObjectSourceList::CommandOptions::modules
std::vector< std::string > modules
Definition: CommandObjectSource.cpp:717
CommandObjectSourceList::CommandOptions::GetDefinitions
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Definition: CommandObjectSource.cpp:706
lldb_private::SymbolContextList::AppendIfUnique
bool AppendIfUnique(const SymbolContext &sc, bool merge_symbol_into_function)
Definition: SymbolContext.cpp:1214
lldb::eReturnStatusFailed
@ eReturnStatusFailed
Definition: lldb-enumerations.h:265
lldb_private::CompileUnit::GetPrimaryFile
const FileSpec & GetPrimaryFile() const
Return the primary source file associated with this compile unit.
Definition: CompileUnit.h:227
lldb_private::CommandReturnObject::GetErrorStream
Stream & GetErrorStream()
Definition: CommandReturnObject.h:55
string
string(SUBSTRING ${p} 10 -1 pStripped) if($
Definition: Plugins/CMakeLists.txt:38
lldb_private::LineEntry::column
uint16_t column
The column number of the source line, or zero if there is no column information.
Definition: LineEntry.h:145
CommandObjectSourceInfo::CommandOptions::SetOptionValue
Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg, ExecutionContext *execution_context) override
Set the value of an option.
Definition: CommandObjectSource.cpp:43
lldb_private::SectionLoadList::ResolveLoadAddress
bool ResolveLoadAddress(lldb::addr_t load_addr, Address &so_addr, bool allow_section_end=false) const
Definition: SectionLoadList.cpp:208
lldb_private::CommandObjectMultiwordSource::~CommandObjectMultiwordSource
~CommandObjectMultiwordSource() override
lldb_private::ArchSpec::GetAddressByteSize
uint32_t GetAddressByteSize() const
Returns the size in bytes of an address of the current architecture.
Definition: ArchSpec.cpp:683
lldb_private::Module::GetNumCompileUnits
size_t GetNumCompileUnits()
Get the number of compile units for this module.
Definition: Module.cpp:420
lldb_private::LineEntry::original_file
FileSpec original_file
The original source file, from debug info.
Definition: LineEntry.h:142
lldb_private::LineEntry::line
uint32_t line
The source line number, or zero if there is no line number information.
Definition: LineEntry.h:143
CommandObjectSourceList::m_options
CommandOptions m_options
Definition: CommandObjectSource.cpp:1262
lldb_private::OptionValueFileColonLine::SetValueFromString
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
Definition: OptionValueFileColonLine.cpp:53
lldb_private::Function::GetStartLineSourceInfo
void GetStartLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the start of the function.
Definition: Function.cpp:243
CommandObjectSourceList::SourceInfo::IsValid
bool IsValid() const
Definition: CommandObjectSource.cpp:763
CommandObjectSourceList::CommandOptions::num_lines
uint32_t num_lines
Definition: CommandObjectSource.cpp:716
Symbol.h
CommandObjectSourceInfo::CommandOptions::num_lines
uint32_t num_lines
Definition: CommandObjectSource.cpp:110
lldb_private::SectionLoadList::IsEmpty
bool IsEmpty() const
Definition: SectionLoadList.cpp:37
lldb_private::ModuleSpec
Definition: ModuleSpec.h:26
lldb_private::Target::GetArchitecture
const ArchSpec & GetArchitecture() const
Definition: Target.h:963
lldb_private::CompileUnit::FindLineEntry
uint32_t FindLineEntry(uint32_t start_idx, uint32_t line, const FileSpec *file_spec_ptr, bool exact, LineEntry *line_entry)
Find the line entry by line and optional inlined file spec.
Definition: CompileUnit.cpp:218
CommandObjectSourceInfo::DumpLinesInSymbolContexts
uint32_t DumpLinesInSymbolContexts(Stream &strm, const SymbolContextList &sc_list, const ModuleList &module_list, const FileSpec &file_spec)
Definition: CommandObjectSource.cpp:136
lldb_private::Status
Definition: Status.h:44
lldb_private::OptionValueFileColonLine
Definition: OptionValueFileColonLine.h:19
CommandObjectSourceInfo::CommandOptions::modules
std::vector< std::string > modules
Definition: CommandObjectSource.cpp:111
CommandObjectSourceInfo::GetOptions
Options * GetOptions() override
Definition: CommandObjectSource.cpp:126
lldb_private::SourceManager::GetLastFile
FileSP GetLastFile()
Definition: SourceManager.h:122
lldb_private::CommandReturnObject
Definition: CommandReturnObject.h:25
uint32_t
CommandObjectSourceList::CommandObjectSourceList
CommandObjectSourceList(CommandInterpreter &interpreter)
Definition: CommandObjectSource.cpp:723
lldb::eReturnStatusSuccessFinishResult
@ eReturnStatusSuccessFinishResult
Definition: lldb-enumerations.h:261
lldb_private::Address
Definition: Address.h:59
lldb_private::Stream::EOL
size_t EOL()
Output and End of Line character to the stream.
Definition: Stream.cpp:128
CommandObjectSourceList::SourceInfo::operator<
bool operator<(const SourceInfo &rhs) const
Definition: CommandObjectSource.cpp:777
lldb_private::CommandReturnObject::AppendMessageWithFormat
void AppendMessageWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:64
CommandObjectSourceList::SourceInfo::line_entry
LineEntry line_entry
Definition: CommandObjectSource.cpp:756
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:310
CommandObjectSourceList::CommandOptions
Definition: CommandObjectSource.cpp:626
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:31
lldb_private::CommandReturnObject::AppendWarningWithFormat
void AppendWarningWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:76
lldb_private::LineEntry::range
AddressRange range
The section offset address range for this line entry.
Definition: LineEntry.h:139
CommandObjectSourceList::CommandOptions::reverse
bool reverse
Definition: CommandObjectSource.cpp:719
lldb_private::Address::Dump
bool Dump(Stream *s, ExecutionContextScope *exe_scope, DumpStyle style, DumpStyle fallback_style=DumpStyleInvalid, uint32_t addr_byte_size=UINT32_MAX) const
Dump a description of this object to a Stream.
Definition: Address.cpp:392
lldb_private::SymbolContext::module_sp
lldb::ModuleSP module_sp
The Module for a given query.
Definition: SymbolContext.h:318
lldb_private::CommandReturnObject::Succeeded
bool Succeeded()
Definition: CommandReturnObject.cpp:135
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1036
CommandObjectSourceInfo::CommandOptions
Definition: CommandObjectSource.cpp:37
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Invalid value definitions.
Definition: lldb-defines.h:85
lldb_private::ConstString::GetCString
const char * GetCString() const
Get the string value as a C string.
Definition: ConstString.h:216
CommandObjectSourceInfo::CommandObjectSourceInfo
CommandObjectSourceInfo(CommandInterpreter &interpreter)
Definition: CommandObjectSource.cpp:115
Function.h
lldb_private::Stream::Printf
size_t Printf(const char *format,...) __attribute__((format(printf
Output printf formatted output to the stream.
Definition: Stream.cpp:107
lldb_private::SearchFilterForUnconstrainedSearches
Definition: SearchFilter.h:289
CommandObjectSourceList::GetBreakpointLocations
const SymbolContextList * GetBreakpointLocations()
Definition: CommandObjectSource.cpp:1256
lldb_private::CommandReturnObject::AppendErrorWithFormat
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:48
lldb_private::SymbolContext::Clear
void Clear(bool clear_target)
Clear the object's state.
Definition: SymbolContext.cpp:58
OptionParser.h
lldb_private::SourceManager::FileSP
std::shared_ptr< File > FileSP
Definition: SourceManager.h:91
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Stream::SetAddressByteSize
void SetAddressByteSize(uint32_t addr_size)
Set the address size in bytes.
Definition: Stream.cpp:182
lldb_private::Args::end
const_iterator end() const
Definition: Args.h:135
CommandObjectSourceList::SourceInfo
Definition: CommandObjectSource.cpp:754
lldb_private::ModuleList::GetModuleAtIndex
lldb::ModuleSP GetModuleAtIndex(size_t idx) const
Get the module shared pointer for the module at index idx.
Definition: ModuleList.cpp:354
CommandObjectSourceInfo::m_options
CommandOptions m_options
Definition: CommandObjectSource.cpp:616
lldb_private::ModuleList::FindFunctions
void FindFunctions(ConstString name, lldb::FunctionNameType name_type_mask, bool include_symbols, bool include_inlines, SymbolContextList &sc_list) const
FileSpec.h
lldb_private::ModuleList::FindModules
void FindModules(const ModuleSpec &module_spec, ModuleList &matching_module_list) const
Finds the first module whose file specification matches file_spec.
Definition: ModuleList.cpp:482
lldb_private::FileSpec::GetDirectory
ConstString & GetDirectory()
Directory string get accessor.
Definition: FileSpec.cpp:335
CommandObjectSourceList::m_reverse_name
std::string m_reverse_name
Definition: CommandObjectSource.cpp:1264
CommandObjectSourceList::SourceInfo::operator==
bool operator==(const SourceInfo &rhs) const
Definition: CommandObjectSource.cpp:765
lldb_private::ModuleList::FindFunctionSymbols
void FindFunctionSymbols(ConstString name, lldb::FunctionNameType name_type_mask, SymbolContextList &sc_list)
Definition: ModuleList.cpp:397
lldb_private::SourceManager::DisplayMoreWithLineNumbers
size_t DisplayMoreWithLineNumbers(Stream *s, uint32_t count, bool reverse, const SymbolContextList *bp_locs=nullptr)
Definition: SourceManager.cpp:266
LLDB_INVALID_INDEX32
#define LLDB_INVALID_INDEX32
Definition: lldb-defines.h:86
lldb_private::Address::GetModule
lldb::ModuleSP GetModule() const
Get accessor for the module for this address.
Definition: Address.cpp:282
lldb_private::Function::GetEndLineSourceInfo
void GetEndLineSourceInfo(FileSpec &source_file, uint32_t &line_no)
Find the file and line number of the source location of the end of the function.
Definition: Function.cpp:271
lldb_private::Target::GetSourceManager
SourceManager & GetSourceManager()
Definition: Target.cpp:2543
lldb_private::SymbolContext::line_entry
LineEntry line_entry
The LineEntry for a given query.
Definition: SymbolContext.h:322
CommandObjectSourceInfo::CommandOptions::OptionParsingStarting
void OptionParsingStarting(ExecutionContext *execution_context) override
Definition: CommandObjectSource.cpp:88
lldb_private::FileSpec::GetPath
size_t GetPath(char *path, size_t max_path_length, bool denormalize=true) const
Extract the full path to the file.
Definition: FileSpec.cpp:348
OptionValueFileColonLine.h
lldb_private::CommandReturnObject::AppendError
void void AppendError(llvm::StringRef in_string)
Definition: CommandReturnObject.cpp:100
lldb_private::StackFrame
Definition: StackFrame.h:40
lldb_private::Args::GetArgumentCount
size_t GetArgumentCount() const
Gets the number of arguments left in this command object.
Definition: Args.h:118
CommandObjectSource.h
CommandObjectSourceInfo::DumpLinesForAddress
bool DumpLinesForAddress(CommandReturnObject &result)
Definition: CommandObjectSource.cpp:464
lldb
Definition: SBAddress.h:15
CommandObjectSourceInfo::CommandOptions::file_spec
FileSpec file_spec
Definition: CommandObjectSource.cpp:104
lldb_private::FileSpec::GetFilename
ConstString & GetFilename()
Filename string get accessor.
Definition: FileSpec.cpp:341
lldb_private::StackFrame::GetSymbolContext
const SymbolContext & GetSymbolContext(lldb::SymbolContextItem resolve_scope)
Provide a SymbolContext for this StackFrame's current pc value.
Definition: StackFrame.cpp:298
lldb_private::OptionValueFileColonLine::GetFileSpec
FileSpec & GetFileSpec()
Definition: OptionValueFileColonLine.h:45
lldb_private::LineEntry
Definition: LineEntry.h:20
CommandObjectSourceList::DoExecute
bool DoExecute(Args &command, CommandReturnObject &result) override
Definition: CommandObjectSource.cpp:930
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:208
CommandObjectSourceList::FindMatchingFunctions
void FindMatchingFunctions(Target *target, ConstString name, SymbolContextList &sc_list)
Definition: CommandObjectSource.cpp:879
CommandObjectSourceList::GetRepeatCommand
const char * GetRepeatCommand(Args &current_command_args, uint32_t index) override
Get the command that appropriate for a "repeat" of the current command.
Definition: CommandObjectSource.cpp:734
CommandObjectSourceList
Definition: CommandObjectSource.cpp:625
lldb_private::Module::GetCompileUnitAtIndex
lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx)
Definition: Module.cpp:429
lldb_private::Status::AsCString
const char * AsCString(const char *default_error_str="unknown error") const
Get the error string associated with the current error.
Definition: Status.cpp:131
CommandObjectSourceInfo::CommandOptions::end_line
uint32_t end_line
Definition: CommandObjectSource.cpp:109