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());
544  return false;
545  }
546 
547  Target *target = m_exe_ctx.GetTargetPtr();
548  if (target == nullptr) {
549  target = GetDebugger().GetSelectedTarget().get();
550  if (target == nullptr) {
551  result.AppendError("invalid target, create a debug target using the "
552  "'target create' command.");
553  return false;
554  }
555  }
556 
557  uint32_t addr_byte_size = target->GetArchitecture().GetAddressByteSize();
558  result.GetOutputStream().SetAddressByteSize(addr_byte_size);
559  result.GetErrorStream().SetAddressByteSize(addr_byte_size);
560 
561  // Collect the list of modules to search.
562  m_module_list.Clear();
563  if (!m_options.modules.empty()) {
564  for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
565  FileSpec module_file_spec(m_options.modules[i]);
566  if (module_file_spec) {
567  ModuleSpec module_spec(module_file_spec);
568  target->GetImages().FindModules(module_spec, m_module_list);
569  if (m_module_list.IsEmpty())
570  result.AppendWarningWithFormat("No module found for '%s'.\n",
571  m_options.modules[i].c_str());
572  }
573  }
574  if (!m_module_list.GetSize()) {
575  result.AppendError("No modules match the input.");
576  return false;
577  }
578  } else if (target->GetImages().GetSize() == 0) {
579  result.AppendError("The target has no associated executable images.");
580  return false;
581  }
582 
583  // Check the arguments to see what lines we should dump.
584  if (!m_options.symbol_name.empty()) {
585  // Print lines for symbol.
586  if (DumpLinesInFunctions(result))
588  else
590  } else if (m_options.address != LLDB_INVALID_ADDRESS) {
591  // Print lines for an address.
592  if (DumpLinesForAddress(result))
594  else
596  } else if (!m_options.file_name.empty()) {
597  // Dump lines for a file.
598  if (DumpLinesForFile(result))
600  else
602  } else {
603  // Dump the line for the current frame.
604  if (DumpLinesForFrame(result))
606  else
608  }
609  return result.Succeeded();
610  }
611 
614 };
615 
616 #pragma mark CommandObjectSourceList
617 // CommandObjectSourceList
618 #define LLDB_OPTIONS_source_list
619 #include "CommandOptions.inc"
620 
622  class CommandOptions : public Options {
623  public:
625 
626  ~CommandOptions() override = default;
627 
628  Status SetOptionValue(uint32_t option_idx, llvm::StringRef option_arg,
629  ExecutionContext *execution_context) override {
630  Status error;
631  const int short_option = GetDefinitions()[option_idx].short_option;
632  switch (short_option) {
633  case 'l':
634  if (option_arg.getAsInteger(0, start_line))
635  error.SetErrorStringWithFormat("invalid line number: '%s'",
636  option_arg.str().c_str());
637  break;
638 
639  case 'c':
640  if (option_arg.getAsInteger(0, num_lines))
641  error.SetErrorStringWithFormat("invalid line count: '%s'",
642  option_arg.str().c_str());
643  break;
644 
645  case 'f':
646  file_name = std::string(option_arg);
647  break;
648 
649  case 'n':
650  symbol_name = std::string(option_arg);
651  break;
652 
653  case 'a': {
654  address = OptionArgParser::ToAddress(execution_context, option_arg,
656  } break;
657  case 's':
658  modules.push_back(std::string(option_arg));
659  break;
660 
661  case 'b':
662  show_bp_locs = true;
663  break;
664  case 'r':
665  reverse = true;
666  break;
667  case 'y':
668  {
670  Status fcl_err = value.SetValueFromString(option_arg);
671  if (!fcl_err.Success()) {
672  error.SetErrorStringWithFormat(
673  "Invalid value for file:line specifier: %s",
674  fcl_err.AsCString());
675  } else {
676  file_name = value.GetFileSpec().GetPath();
677  start_line = value.GetLineNumber();
678  // I don't see anything useful to do with a column number, but I don't
679  // want to complain since someone may well have cut and pasted a
680  // listing from somewhere that included a column.
681  }
682  } break;
683  default:
684  llvm_unreachable("Unimplemented option");
685  }
686 
687  return error;
688  }
689 
690  void OptionParsingStarting(ExecutionContext *execution_context) override {
691  file_spec.Clear();
692  file_name.clear();
693  symbol_name.clear();
694  address = LLDB_INVALID_ADDRESS;
695  start_line = 0;
696  num_lines = 0;
697  show_bp_locs = false;
698  reverse = false;
699  modules.clear();
700  }
701 
702  llvm::ArrayRef<OptionDefinition> GetDefinitions() override {
703  return llvm::makeArrayRef(g_source_list_options);
704  }
705 
706  // Instance variables to hold the values for command options.
713  std::vector<std::string> modules;
715  bool reverse;
716  };
717 
718 public:
720  : CommandObjectParsed(interpreter, "source list",
721  "Display source code for the current target "
722  "process as specified by options.",
723  nullptr, eCommandRequiresTarget),
724  m_options() {}
725 
726  ~CommandObjectSourceList() override = default;
727 
728  Options *GetOptions() override { return &m_options; }
729 
730  const char *GetRepeatCommand(Args &current_command_args,
731  uint32_t index) override {
732  // This is kind of gross, but the command hasn't been parsed yet so we
733  // can't look at the option values for this invocation... I have to scan
734  // the arguments directly.
735  auto iter =
736  llvm::find_if(current_command_args, [](const Args::ArgEntry &e) {
737  return e.ref() == "-r" || e.ref() == "--reverse";
738  });
739  if (iter == current_command_args.end())
740  return m_cmd_name.c_str();
741 
742  if (m_reverse_name.empty()) {
743  m_reverse_name = m_cmd_name;
744  m_reverse_name.append(" -r");
745  }
746  return m_reverse_name.c_str();
747  }
748 
749 protected:
750  struct SourceInfo {
751  ConstString function;
753 
754  SourceInfo(ConstString name, const LineEntry &line_entry)
755  : function(name), line_entry(line_entry) {}
756 
757  SourceInfo() : function(), line_entry() {}
758 
759  bool IsValid() const { return (bool)function && line_entry.IsValid(); }
760 
761  bool operator==(const SourceInfo &rhs) const {
762  return function == rhs.function &&
763  line_entry.original_file == rhs.line_entry.original_file &&
764  line_entry.line == rhs.line_entry.line;
765  }
766 
767  bool operator!=(const SourceInfo &rhs) const {
768  return function != rhs.function ||
769  line_entry.original_file != rhs.line_entry.original_file ||
770  line_entry.line != rhs.line_entry.line;
771  }
772 
773  bool operator<(const SourceInfo &rhs) const {
774  if (function.GetCString() < rhs.function.GetCString())
775  return true;
776  if (line_entry.file.GetDirectory().GetCString() <
778  return true;
779  if (line_entry.file.GetFilename().GetCString() <
781  return true;
782  if (line_entry.line < rhs.line_entry.line)
783  return true;
784  return false;
785  }
786  };
787 
788  size_t DisplayFunctionSource(const SymbolContext &sc, SourceInfo &source_info,
789  CommandReturnObject &result) {
790  if (!source_info.IsValid()) {
791  source_info.function = sc.GetFunctionName();
792  source_info.line_entry = sc.GetFunctionStartLineEntry();
793  }
794 
795  if (sc.function) {
796  Target *target = m_exe_ctx.GetTargetPtr();
797 
798  FileSpec start_file;
799  uint32_t start_line;
800  uint32_t end_line;
801  FileSpec end_file;
802 
803  if (sc.block == nullptr) {
804  // Not an inlined function
805  sc.function->GetStartLineSourceInfo(start_file, start_line);
806  if (start_line == 0) {
807  result.AppendErrorWithFormat("Could not find line information for "
808  "start of function: \"%s\".\n",
809  source_info.function.GetCString());
810  return 0;
811  }
812  sc.function->GetEndLineSourceInfo(end_file, end_line);
813  } else {
814  // We have an inlined function
815  start_file = source_info.line_entry.file;
816  start_line = source_info.line_entry.line;
817  end_line = start_line + m_options.num_lines;
818  }
819 
820  // This is a little hacky, but the first line table entry for a function
821  // points to the "{" that starts the function block. It would be nice to
822  // actually get the function declaration in there too. So back up a bit,
823  // but not further than what you're going to display.
824  uint32_t extra_lines;
825  if (m_options.num_lines >= 10)
826  extra_lines = 5;
827  else
828  extra_lines = m_options.num_lines / 2;
829  uint32_t line_no;
830  if (start_line <= extra_lines)
831  line_no = 1;
832  else
833  line_no = start_line - extra_lines;
834 
835  // For fun, if the function is shorter than the number of lines we're
836  // supposed to display, only display the function...
837  if (end_line != 0) {
838  if (m_options.num_lines > end_line - line_no)
839  m_options.num_lines = end_line - line_no + extra_lines;
840  }
841 
842  m_breakpoint_locations.Clear();
843 
844  if (m_options.show_bp_locs) {
845  const bool show_inlines = true;
846  m_breakpoint_locations.Reset(start_file, 0, show_inlines);
847  SearchFilterForUnconstrainedSearches target_search_filter(
848  m_exe_ctx.GetTargetSP());
849  target_search_filter.Search(m_breakpoint_locations);
850  }
851 
852  result.AppendMessageWithFormat("File: %s\n",
853  start_file.GetPath().c_str());
854  // We don't care about the column here.
855  const uint32_t column = 0;
857  start_file, line_no, column, 0, m_options.num_lines, "",
858  &result.GetOutputStream(), GetBreakpointLocations());
859  } else {
860  result.AppendErrorWithFormat(
861  "Could not find function info for: \"%s\".\n",
862  m_options.symbol_name.c_str());
863  }
864  return 0;
865  }
866 
867  // From Jim: The FindMatchingFunctions / FindMatchingFunctionSymbols
868  // functions "take a possibly empty vector of strings which are names of
869  // modules, and run the two search functions on the subset of the full module
870  // list that matches the strings in the input vector". If we wanted to put
871  // these somewhere, there should probably be a module-filter-list that can be
872  // passed to the various ModuleList::Find* calls, which would either be a
873  // vector of string names or a ModuleSpecList.
875  SymbolContextList &sc_list) {
876  // Displaying the source for a symbol:
877  bool include_inlines = true;
878  bool include_symbols = false;
879 
880  if (m_options.num_lines == 0)
881  m_options.num_lines = 10;
882 
883  const size_t num_modules = m_options.modules.size();
884  if (num_modules > 0) {
885  ModuleList matching_modules;
886  for (size_t i = 0; i < num_modules; ++i) {
887  FileSpec module_file_spec(m_options.modules[i]);
888  if (module_file_spec) {
889  ModuleSpec module_spec(module_file_spec);
890  matching_modules.Clear();
891  target->GetImages().FindModules(module_spec, matching_modules);
892  matching_modules.FindFunctions(name, eFunctionNameTypeAuto,
893  include_symbols, include_inlines,
894  sc_list);
895  }
896  }
897  } else {
898  target->GetImages().FindFunctions(name, eFunctionNameTypeAuto,
899  include_symbols, include_inlines,
900  sc_list);
901  }
902  }
903 
905  SymbolContextList &sc_list) {
906  const size_t num_modules = m_options.modules.size();
907  if (num_modules > 0) {
908  ModuleList matching_modules;
909  for (size_t i = 0; i < num_modules; ++i) {
910  FileSpec module_file_spec(m_options.modules[i]);
911  if (module_file_spec) {
912  ModuleSpec module_spec(module_file_spec);
913  matching_modules.Clear();
914  target->GetImages().FindModules(module_spec, matching_modules);
915  matching_modules.FindFunctionSymbols(name, eFunctionNameTypeAuto,
916  sc_list);
917  }
918  }
919  } else {
920  target->GetImages().FindFunctionSymbols(name, eFunctionNameTypeAuto,
921  sc_list);
922  }
923  }
924 
925  bool DoExecute(Args &command, CommandReturnObject &result) override {
926  const size_t argc = command.GetArgumentCount();
927 
928  if (argc != 0) {
929  result.AppendErrorWithFormat("'%s' takes no arguments, only flags.\n",
930  GetCommandName().str().c_str());
931  return false;
932  }
933 
934  Target *target = m_exe_ctx.GetTargetPtr();
935 
936  if (!m_options.symbol_name.empty()) {
937  SymbolContextList sc_list;
938  ConstString name(m_options.symbol_name.c_str());
939 
940  // Displaying the source for a symbol. Search for function named name.
941  FindMatchingFunctions(target, name, sc_list);
942  size_t num_matches = sc_list.GetSize();
943  if (!num_matches) {
944  // If we didn't find any functions with that name, try searching for
945  // symbols that line up exactly with function addresses.
946  SymbolContextList sc_list_symbols;
947  FindMatchingFunctionSymbols(target, name, sc_list_symbols);
948  size_t num_symbol_matches = sc_list_symbols.GetSize();
949 
950  for (size_t i = 0; i < num_symbol_matches; i++) {
951  SymbolContext sc;
952  sc_list_symbols.GetContextAtIndex(i, sc);
953  if (sc.symbol && sc.symbol->ValueIsAddress()) {
954  const Address &base_address = sc.symbol->GetAddressRef();
955  Function *function = base_address.CalculateSymbolContextFunction();
956  if (function) {
957  sc_list.Append(SymbolContext(function));
958  num_matches++;
959  break;
960  }
961  }
962  }
963  }
964 
965  if (num_matches == 0) {
966  result.AppendErrorWithFormat("Could not find function named: \"%s\".\n",
967  m_options.symbol_name.c_str());
968  return false;
969  }
970 
971  if (num_matches > 1) {
972  std::set<SourceInfo> source_match_set;
973 
974  bool displayed_something = false;
975  for (size_t i = 0; i < num_matches; i++) {
976  SymbolContext sc;
977  sc_list.GetContextAtIndex(i, sc);
978  SourceInfo source_info(sc.GetFunctionName(),
980 
981  if (source_info.IsValid()) {
982  if (source_match_set.find(source_info) == source_match_set.end()) {
983  source_match_set.insert(source_info);
984  if (DisplayFunctionSource(sc, source_info, result))
985  displayed_something = true;
986  }
987  }
988  }
989 
990  if (displayed_something)
992  else
994  } else {
995  SymbolContext sc;
996  sc_list.GetContextAtIndex(0, sc);
997  SourceInfo source_info;
998 
999  if (DisplayFunctionSource(sc, source_info, result)) {
1001  } else {
1003  }
1004  }
1005  return result.Succeeded();
1006  } else if (m_options.address != LLDB_INVALID_ADDRESS) {
1007  Address so_addr;
1008  StreamString error_strm;
1009  SymbolContextList sc_list;
1010 
1011  if (target->GetSectionLoadList().IsEmpty()) {
1012  // The target isn't loaded yet, we need to lookup the file address in
1013  // all modules
1014  const ModuleList &module_list = target->GetImages();
1015  const size_t num_modules = module_list.GetSize();
1016  for (size_t i = 0; i < num_modules; ++i) {
1017  ModuleSP module_sp(module_list.GetModuleAtIndex(i));
1018  if (module_sp &&
1019  module_sp->ResolveFileAddress(m_options.address, so_addr)) {
1020  SymbolContext sc;
1021  sc.Clear(true);
1022  if (module_sp->ResolveSymbolContextForAddress(
1023  so_addr, eSymbolContextEverything, sc) &
1024  eSymbolContextLineEntry)
1025  sc_list.Append(sc);
1026  }
1027  }
1028 
1029  if (sc_list.GetSize() == 0) {
1030  result.AppendErrorWithFormat(
1031  "no modules have source information for file address 0x%" PRIx64
1032  ".\n",
1033  m_options.address);
1034  return false;
1035  }
1036  } else {
1037  // The target has some things loaded, resolve this address to a compile
1038  // unit + file + line and display
1039  if (target->GetSectionLoadList().ResolveLoadAddress(m_options.address,
1040  so_addr)) {
1041  ModuleSP module_sp(so_addr.GetModule());
1042  if (module_sp) {
1043  SymbolContext sc;
1044  sc.Clear(true);
1045  if (module_sp->ResolveSymbolContextForAddress(
1046  so_addr, eSymbolContextEverything, sc) &
1047  eSymbolContextLineEntry) {
1048  sc_list.Append(sc);
1049  } else {
1050  so_addr.Dump(&error_strm, nullptr,
1051  Address::DumpStyleModuleWithFileAddress);
1052  result.AppendErrorWithFormat("address resolves to %s, but there "
1053  "is no line table information "
1054  "available for this address.\n",
1055  error_strm.GetData());
1056  return false;
1057  }
1058  }
1059  }
1060 
1061  if (sc_list.GetSize() == 0) {
1062  result.AppendErrorWithFormat(
1063  "no modules contain load address 0x%" PRIx64 ".\n",
1064  m_options.address);
1065  return false;
1066  }
1067  }
1068  uint32_t num_matches = sc_list.GetSize();
1069  for (uint32_t i = 0; i < num_matches; ++i) {
1070  SymbolContext sc;
1071  sc_list.GetContextAtIndex(i, sc);
1072  if (sc.comp_unit) {
1073  if (m_options.show_bp_locs) {
1074  m_breakpoint_locations.Clear();
1075  const bool show_inlines = true;
1076  m_breakpoint_locations.Reset(sc.comp_unit->GetPrimaryFile(), 0,
1077  show_inlines);
1078  SearchFilterForUnconstrainedSearches target_search_filter(
1079  target->shared_from_this());
1080  target_search_filter.Search(m_breakpoint_locations);
1081  }
1082 
1083  bool show_fullpaths = true;
1084  bool show_module = true;
1085  bool show_inlined_frames = true;
1086  const bool show_function_arguments = true;
1087  const bool show_function_name = true;
1088  sc.DumpStopContext(&result.GetOutputStream(),
1089  m_exe_ctx.GetBestExecutionContextScope(),
1091  show_fullpaths, show_module, show_inlined_frames,
1092  show_function_arguments, show_function_name);
1093  result.GetOutputStream().EOL();
1094 
1095  if (m_options.num_lines == 0)
1096  m_options.num_lines = 10;
1097 
1098  size_t lines_to_back_up =
1099  m_options.num_lines >= 10 ? 5 : m_options.num_lines / 2;
1100 
1101  const uint32_t column =
1102  (GetDebugger().GetStopShowColumn() != eStopShowColumnNone)
1103  ? sc.line_entry.column
1104  : 0;
1106  sc.comp_unit->GetPrimaryFile(), sc.line_entry.line, column,
1107  lines_to_back_up, m_options.num_lines - lines_to_back_up, "->",
1108  &result.GetOutputStream(), GetBreakpointLocations());
1110  }
1111  }
1112  } else if (m_options.file_name.empty()) {
1113  // Last valid source manager context, or the current frame if no valid
1114  // last context in source manager. One little trick here, if you type the
1115  // exact same list command twice in a row, it is more likely because you
1116  // typed it once, then typed it again
1117  if (m_options.start_line == 0) {
1119  &result.GetOutputStream(), m_options.num_lines,
1120  m_options.reverse, GetBreakpointLocations())) {
1122  }
1123  } else {
1124  if (m_options.num_lines == 0)
1125  m_options.num_lines = 10;
1126 
1127  if (m_options.show_bp_locs) {
1128  SourceManager::FileSP last_file_sp(
1129  target->GetSourceManager().GetLastFile());
1130  if (last_file_sp) {
1131  const bool show_inlines = true;
1132  m_breakpoint_locations.Reset(last_file_sp->GetFileSpec(), 0,
1133  show_inlines);
1134  SearchFilterForUnconstrainedSearches target_search_filter(
1135  target->shared_from_this());
1136  target_search_filter.Search(m_breakpoint_locations);
1137  }
1138  } else
1139  m_breakpoint_locations.Clear();
1140 
1141  const uint32_t column = 0;
1142  if (target->GetSourceManager()
1144  m_options.start_line, // Line to display
1145  m_options.num_lines, // Lines after line to
1146  UINT32_MAX, // Don't mark "line"
1147  column,
1148  "", // Don't mark "line"
1149  &result.GetOutputStream(), GetBreakpointLocations())) {
1151  }
1152  }
1153  } else {
1154  const char *filename = m_options.file_name.c_str();
1155 
1156  bool check_inlines = false;
1157  SymbolContextList sc_list;
1158  size_t num_matches = 0;
1159 
1160  if (!m_options.modules.empty()) {
1161  ModuleList matching_modules;
1162  for (size_t i = 0, e = m_options.modules.size(); i < e; ++i) {
1163  FileSpec module_file_spec(m_options.modules[i]);
1164  if (module_file_spec) {
1165  ModuleSpec module_spec(module_file_spec);
1166  matching_modules.Clear();
1167  target->GetImages().FindModules(module_spec, matching_modules);
1168  num_matches += matching_modules.ResolveSymbolContextForFilePath(
1169  filename, 0, check_inlines,
1170  SymbolContextItem(eSymbolContextModule |
1171  eSymbolContextCompUnit),
1172  sc_list);
1173  }
1174  }
1175  } else {
1176  num_matches = target->GetImages().ResolveSymbolContextForFilePath(
1177  filename, 0, check_inlines,
1178  eSymbolContextModule | eSymbolContextCompUnit, sc_list);
1179  }
1180 
1181  if (num_matches == 0) {
1182  result.AppendErrorWithFormat("Could not find source file \"%s\".\n",
1183  m_options.file_name.c_str());
1184  return false;
1185  }
1186 
1187  if (num_matches > 1) {
1188  bool got_multiple = false;
1189  CompileUnit *test_cu = nullptr;
1190 
1191  for (unsigned i = 0; i < num_matches; i++) {
1192  SymbolContext sc;
1193  sc_list.GetContextAtIndex(i, sc);
1194  if (sc.comp_unit) {
1195  if (test_cu) {
1196  if (test_cu != sc.comp_unit)
1197  got_multiple = true;
1198  break;
1199  } else
1200  test_cu = sc.comp_unit;
1201  }
1202  }
1203  if (got_multiple) {
1204  result.AppendErrorWithFormat(
1205  "Multiple source files found matching: \"%s.\"\n",
1206  m_options.file_name.c_str());
1207  return false;
1208  }
1209  }
1210 
1211  SymbolContext sc;
1212  if (sc_list.GetContextAtIndex(0, sc)) {
1213  if (sc.comp_unit) {
1214  if (m_options.show_bp_locs) {
1215  const bool show_inlines = true;
1216  m_breakpoint_locations.Reset(sc.comp_unit->GetPrimaryFile(), 0,
1217  show_inlines);
1218  SearchFilterForUnconstrainedSearches target_search_filter(
1219  target->shared_from_this());
1220  target_search_filter.Search(m_breakpoint_locations);
1221  } else
1222  m_breakpoint_locations.Clear();
1223 
1224  if (m_options.num_lines == 0)
1225  m_options.num_lines = 10;
1226  const uint32_t column = 0;
1228  sc.comp_unit->GetPrimaryFile(), m_options.start_line, column, 0,
1229  m_options.num_lines, "", &result.GetOutputStream(),
1230  GetBreakpointLocations());
1231 
1233  } else {
1234  result.AppendErrorWithFormat("No comp unit found for: \"%s.\"\n",
1235  m_options.file_name.c_str());
1236  return false;
1237  }
1238  }
1239  }
1240  return result.Succeeded();
1241  }
1242 
1244  if (m_breakpoint_locations.GetFileLineMatches().GetSize() > 0)
1245  return &m_breakpoint_locations.GetFileLineMatches();
1246  return nullptr;
1247  }
1248 
1252 };
1253 
1254 #pragma mark CommandObjectMultiwordSource
1255 // CommandObjectMultiwordSource
1256 
1257 CommandObjectMultiwordSource::CommandObjectMultiwordSource(
1258  CommandInterpreter &interpreter)
1259  : CommandObjectMultiword(interpreter, "source",
1260  "Commands for examining "
1261  "source code described by "
1262  "debug information for the "
1263  "current target process.",
1264  "source <subcommand> [<subcommand-options>]") {
1265  LoadSubCommand("info",
1266  CommandObjectSP(new CommandObjectSourceInfo(interpreter)));
1267  LoadSubCommand("list",
1268  CommandObjectSP(new CommandObjectSourceList(interpreter)));
1269 }
1270 
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:710
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:628
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
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:788
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:709
CompileUnit.h
lldb_private::LineEntry::IsValid
bool IsValid() const
Check if a line entry object is valid.
Definition: LineEntry.cpp:46
ModuleSpec.h
lldb_private::Address::CalculateSymbolContextFunction
Function * CalculateSymbolContextFunction() const
Definition: Address.cpp:835
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
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:380
lldb_private::SymbolContextList::Append
void Append(const SymbolContext &sc)
Append a new symbol context to the list.
Definition: SymbolContext.cpp:1191
lldb_private::ModuleList::GetIndexForModule
size_t GetIndexForModule(const Module *module) const
Definition: ModuleList.cpp:686
CommandObjectSourceInfo
Definition: CommandObjectSource.cpp:36
CommandObjectSourceList::CommandOptions::show_bp_locs
bool show_bp_locs
Definition: CommandObjectSource.cpp:714
lldb_private::ModuleList::GetModulePointerAtIndex
Module * GetModulePointerAtIndex(size_t idx) const
Get the module pointer for the module at index idx.
Definition: ModuleList.cpp:346
CommandObjectSourceInfo::m_module_list
ModuleList m_module_list
Definition: CommandObjectSource.cpp:613
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:904
SourceManager.h
lldb_private::SymbolContextList
Definition: SymbolContext.h:379
lldb_private::SymbolContextList::GetContextAtIndex
bool GetContextAtIndex(size_t idx, SymbolContext &sc) const
Get accessor for a symbol context at index idx.
Definition: SymbolContext.cpp:1265
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:708
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:754
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:1250
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:445
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:335
lldb_private::Target::GetImages
const ModuleList & GetImages() const
Get accessor for the images for this process.
Definition: Target.h:919
CommandObjectSourceList::CommandOptions::start_line
uint32_t start_line
Definition: CommandObjectSource.cpp:711
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:105
lldb_private::CompileUnit
Definition: CompileUnit.h:38
CommandObjectSourceList::SourceInfo::function
ConstString function
Definition: CommandObjectSource.cpp:751
CommandObjectSourceInfo::DumpLinesForFile
bool DumpLinesForFile(CommandReturnObject &result)
Definition: CommandObjectSource.cpp:487
CommandObjectSourceList::SourceInfo::operator!=
bool operator!=(const SourceInfo &rhs) const
Definition: CommandObjectSource.cpp:767
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:690
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:595
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:68
lldb_private::ModuleList
Definition: ModuleList.h:71
CommandObjectSourceList::SourceInfo::SourceInfo
SourceInfo()
Definition: CommandObjectSource.cpp:757
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:675
lldb_private::CommandReturnObject::SetStatus
void SetStatus(lldb::ReturnStatus status)
Definition: CommandReturnObject.cpp:121
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:665
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:1281
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:654
CommandObjectSourceList::CommandOptions::file_spec
FileSpec file_spec
Definition: CommandObjectSource.cpp:707
CommandObjectSourceList::CommandOptions::CommandOptions
CommandOptions()
Definition: CommandObjectSource.cpp:624
CommandObjectSourceList::GetOptions
Options * GetOptions() override
Definition: CommandObjectSource.cpp:728
lldb_private::CommandInterpreter
Definition: CommandInterpreter.h:214
lldb::eStopShowColumnNone
@ eStopShowColumnNone
Definition: lldb-enumerations.h:504
CommandObjectSourceList::CommandOptions::modules
std::vector< std::string > modules
Definition: CommandObjectSource.cpp:713
CommandObjectSourceList::CommandOptions::GetDefinitions
llvm::ArrayRef< OptionDefinition > GetDefinitions() override
Definition: CommandObjectSource.cpp:702
lldb_private::SymbolContextList::AppendIfUnique
bool AppendIfUnique(const SymbolContext &sc, bool merge_symbol_into_function)
Definition: SymbolContext.cpp:1212
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:39
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:146
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:418
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:1249
lldb_private::OptionValueFileColonLine::SetValueFromString
Status SetValueFromString(llvm::StringRef value, VarSetOperationType op=eVarSetOperationAssign) override
Definition: OptionValueFileColonLine.cpp:50
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:759
CommandObjectSourceList::CommandOptions::num_lines
uint32_t num_lines
Definition: CommandObjectSource.cpp:712
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:961
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:719
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:773
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:752
lldb_private::Address::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Get the load address.
Definition: Address.cpp:310
CommandObjectSourceList::CommandOptions
Definition: CommandObjectSource.cpp:622
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:715
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:125
lldb_private::Target::GetSectionLoadList
SectionLoadList & GetSectionLoadList()
Definition: Target.h:1034
CommandObjectSourceInfo::CommandOptions
Definition: CommandObjectSource.cpp:37
LLDB_INVALID_ADDRESS
#define LLDB_INVALID_ADDRESS
Definition: lldb-defines.h:86
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:1243
lldb_private::CommandReturnObject::AppendErrorWithFormat
void AppendErrorWithFormat(const char *format,...) __attribute__((format(printf
Definition: CommandReturnObject.cpp:46
lldb_private::SymbolContext::Clear
void Clear(bool clear_target)
Clear the object's state.
Definition: SymbolContext.cpp:56
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:750
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:353
CommandObjectSourceInfo::m_options
CommandOptions m_options
Definition: CommandObjectSource.cpp:612
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:481
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:1251
CommandObjectSourceList::SourceInfo::operator==
bool operator==(const SourceInfo &rhs) const
Definition: CommandObjectSource.cpp:761
lldb_private::ModuleList::FindFunctionSymbols
void FindFunctionSymbols(ConstString name, lldb::FunctionNameType name_type_mask, SymbolContextList &sc_list)
Definition: ModuleList.cpp:396
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:87
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:2539
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:925
lldb::eDescriptionLevelBrief
@ eDescriptionLevelBrief
Definition: lldb-enumerations.h:208
CommandObjectSourceList::FindMatchingFunctions
void FindMatchingFunctions(Target *target, ConstString name, SymbolContextList &sc_list)
Definition: CommandObjectSource.cpp:874
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:730
CommandObjectSourceList
Definition: CommandObjectSource.cpp:621
lldb_private::Module::GetCompileUnitAtIndex
lldb::CompUnitSP GetCompileUnitAtIndex(size_t idx)
Definition: Module.cpp:427
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