LLDB  mainline
SBTarget.h
Go to the documentation of this file.
1 //===-- SBTarget.h ----------------------------------------------*- C++ -*-===//
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 #ifndef LLDB_API_SBTARGET_H
10 #define LLDB_API_SBTARGET_H
11 
12 #include "lldb/API/SBAddress.h"
13 #include "lldb/API/SBAttachInfo.h"
14 #include "lldb/API/SBBreakpoint.h"
15 #include "lldb/API/SBBroadcaster.h"
16 #include "lldb/API/SBDefines.h"
17 #include "lldb/API/SBFileSpec.h"
19 #include "lldb/API/SBLaunchInfo.h"
21 #include "lldb/API/SBType.h"
22 #include "lldb/API/SBValue.h"
23 #include "lldb/API/SBWatchpoint.h"
24 
25 namespace lldb {
26 
27 class SBPlatform;
28 
30 public:
31  // Broadcaster bits.
32  enum {
33  eBroadcastBitBreakpointChanged = (1 << 0),
34  eBroadcastBitModulesLoaded = (1 << 1),
35  eBroadcastBitModulesUnloaded = (1 << 2),
36  eBroadcastBitWatchpointChanged = (1 << 3),
37  eBroadcastBitSymbolsLoaded = (1 << 4)
38  };
39 
40  // Constructors
41  SBTarget();
42 
43  SBTarget(const lldb::SBTarget &rhs);
44 
45  SBTarget(const lldb::TargetSP &target_sp);
46 
47  // Destructor
48  ~SBTarget();
49 
50  const lldb::SBTarget &operator=(const lldb::SBTarget &rhs);
51 
52  explicit operator bool() const;
53 
54  bool IsValid() const;
55 
56  static bool EventIsTargetEvent(const lldb::SBEvent &event);
57 
58  static lldb::SBTarget GetTargetFromEvent(const lldb::SBEvent &event);
59 
60  static uint32_t GetNumModulesFromEvent(const lldb::SBEvent &event);
61 
62  static lldb::SBModule GetModuleAtIndexFromEvent(const uint32_t idx,
63  const lldb::SBEvent &event);
64 
65  static const char *GetBroadcasterClassName();
66 
67  lldb::SBProcess GetProcess();
68 
69  /// Sets whether we should collect statistics on lldb or not.
70  ///
71  /// \param[in] v
72  /// A boolean to control the collection.
73  void SetCollectingStats(bool v);
74 
75  /// Returns whether statistics collection are enabled.
76  ///
77  /// \return
78  /// true if statistics are currently being collected, false
79  /// otherwise.
80  bool GetCollectingStats();
81 
82  /// Returns a dump of the collected statistics.
83  ///
84  /// \return
85  /// A SBStructuredData with the statistics collected.
86  lldb::SBStructuredData GetStatistics();
87 
88  /// Return the platform object associated with the target.
89  ///
90  /// After return, the platform object should be checked for
91  /// validity.
92  ///
93  /// \return
94  /// A platform object.
95  lldb::SBPlatform GetPlatform();
96 
97  /// Return the environment variables that would be used to launch a new
98  /// process.
99  ///
100  /// \return
101  /// An lldb::SBEnvironment object which is a copy of the target's
102  /// environment.
103 
104  SBEnvironment GetEnvironment();
105 
106  /// Install any binaries that need to be installed.
107  ///
108  /// This function does nothing when debugging on the host system.
109  /// When connected to remote platforms, the target's main executable
110  /// and any modules that have their remote install path set will be
111  /// installed on the remote platform. If the main executable doesn't
112  /// have an install location set, it will be installed in the remote
113  /// platform's working directory.
114  ///
115  /// \return
116  /// An error describing anything that went wrong during
117  /// installation.
118  SBError Install();
119 
120  /// Launch a new process.
121  ///
122  /// Launch a new process by spawning a new process using the
123  /// target object's executable module's file as the file to launch.
124  /// Arguments are given in \a argv, and the environment variables
125  /// are in \a envp. Standard input and output files can be
126  /// optionally re-directed to \a stdin_path, \a stdout_path, and
127  /// \a stderr_path.
128  ///
129  /// \param[in] listener
130  /// An optional listener that will receive all process events.
131  /// If \a listener is valid then \a listener will listen to all
132  /// process events. If not valid, then this target's debugger
133  /// (SBTarget::GetDebugger()) will listen to all process events.
134  ///
135  /// \param[in] argv
136  /// The argument array.
137  ///
138  /// \param[in] envp
139  /// The environment array. If this is null, the default
140  /// environment values (provided through `settings set
141  /// target.env-vars`) will be used.
142  ///
143  /// \param[in] stdin_path
144  /// The path to use when re-directing the STDIN of the new
145  /// process. If all stdXX_path arguments are nullptr, a pseudo
146  /// terminal will be used.
147  ///
148  /// \param[in] stdout_path
149  /// The path to use when re-directing the STDOUT of the new
150  /// process. If all stdXX_path arguments are nullptr, a pseudo
151  /// terminal will be used.
152  ///
153  /// \param[in] stderr_path
154  /// The path to use when re-directing the STDERR of the new
155  /// process. If all stdXX_path arguments are nullptr, a pseudo
156  /// terminal will be used.
157  ///
158  /// \param[in] working_directory
159  /// The working directory to have the child process run in
160  ///
161  /// \param[in] launch_flags
162  /// Some launch options specified by logical OR'ing
163  /// lldb::LaunchFlags enumeration values together.
164  ///
165  /// \param[in] stop_at_entry
166  /// If false do not stop the inferior at the entry point.
167  ///
168  /// \param[out] error
169  /// An error object. Contains the reason if there is some failure.
170  ///
171  /// \return
172  /// A process object for the newly created process.
173  lldb::SBProcess Launch(SBListener &listener, char const **argv,
174  char const **envp, const char *stdin_path,
175  const char *stdout_path, const char *stderr_path,
176  const char *working_directory,
177  uint32_t launch_flags, // See LaunchFlags
178  bool stop_at_entry, lldb::SBError &error);
179 
180  SBProcess LoadCore(const char *core_file);
181  SBProcess LoadCore(const char *core_file, lldb::SBError &error);
182 
183  /// Launch a new process with sensible defaults.
184  ///
185  /// \param[in] argv
186  /// The argument array.
187  ///
188  /// \param[in] envp
189  /// The environment array. If this isn't provided, the default
190  /// environment values (provided through `settings set
191  /// target.env-vars`) will be used.
192  ///
193  /// \param[in] working_directory
194  /// The working directory to have the child process run in
195  ///
196  /// Default: listener
197  /// Set to the target's debugger (SBTarget::GetDebugger())
198  ///
199  /// Default: launch_flags
200  /// Empty launch flags
201  ///
202  /// Default: stdin_path
203  /// Default: stdout_path
204  /// Default: stderr_path
205  /// A pseudo terminal will be used.
206  ///
207  /// \return
208  /// A process object for the newly created process.
209  SBProcess LaunchSimple(const char **argv, const char **envp,
210  const char *working_directory);
211 
212  SBProcess Launch(SBLaunchInfo &launch_info, SBError &error);
213 
214  SBProcess Attach(SBAttachInfo &attach_info, SBError &error);
215 
216  /// Attach to process with pid.
217  ///
218  /// \param[in] listener
219  /// An optional listener that will receive all process events.
220  /// If \a listener is valid then \a listener will listen to all
221  /// process events. If not valid, then this target's debugger
222  /// (SBTarget::GetDebugger()) will listen to all process events.
223  ///
224  /// \param[in] pid
225  /// The process ID to attach to.
226  ///
227  /// \param[out] error
228  /// An error explaining what went wrong if attach fails.
229  ///
230  /// \return
231  /// A process object for the attached process.
232  lldb::SBProcess AttachToProcessWithID(SBListener &listener, lldb::pid_t pid,
234 
235  /// Attach to process with name.
236  ///
237  /// \param[in] listener
238  /// An optional listener that will receive all process events.
239  /// If \a listener is valid then \a listener will listen to all
240  /// process events. If not valid, then this target's debugger
241  /// (SBTarget::GetDebugger()) will listen to all process events.
242  ///
243  /// \param[in] name
244  /// Basename of process to attach to.
245  ///
246  /// \param[in] wait_for
247  /// If true wait for a new instance of 'name' to be launched.
248  ///
249  /// \param[out] error
250  /// An error explaining what went wrong if attach fails.
251  ///
252  /// \return
253  /// A process object for the attached process.
254  lldb::SBProcess AttachToProcessWithName(SBListener &listener,
255  const char *name, bool wait_for,
257 
258  /// Connect to a remote debug server with url.
259  ///
260  /// \param[in] listener
261  /// An optional listener that will receive all process events.
262  /// If \a listener is valid then \a listener will listen to all
263  /// process events. If not valid, then this target's debugger
264  /// (SBTarget::GetDebugger()) will listen to all process events.
265  ///
266  /// \param[in] url
267  /// The url to connect to, e.g., 'connect://localhost:12345'.
268  ///
269  /// \param[in] plugin_name
270  /// The plugin name to be used; can be nullptr.
271  ///
272  /// \param[out] error
273  /// An error explaining what went wrong if the connect fails.
274  ///
275  /// \return
276  /// A process object for the connected process.
277  lldb::SBProcess ConnectRemote(SBListener &listener, const char *url,
278  const char *plugin_name, SBError &error);
279 
280  lldb::SBFileSpec GetExecutable();
281 
282  // Append the path mapping (from -> to) to the target's paths mapping list.
283  void AppendImageSearchPath(const char *from, const char *to,
285 
286  bool AddModule(lldb::SBModule &module);
287 
288  lldb::SBModule AddModule(const char *path, const char *triple,
289  const char *uuid);
290 
291  lldb::SBModule AddModule(const char *path, const char *triple,
292  const char *uuid_cstr, const char *symfile);
293 
294  lldb::SBModule AddModule(const SBModuleSpec &module_spec);
295 
296  uint32_t GetNumModules() const;
297 
298  lldb::SBModule GetModuleAtIndex(uint32_t idx);
299 
300  bool RemoveModule(lldb::SBModule module);
301 
302  lldb::SBDebugger GetDebugger() const;
303 
304  lldb::SBModule FindModule(const lldb::SBFileSpec &file_spec);
305 
306  /// Find compile units related to *this target and passed source
307  /// file.
308  ///
309  /// \param[in] sb_file_spec
310  /// A lldb::SBFileSpec object that contains source file
311  /// specification.
312  ///
313  /// \return
314  /// A lldb::SBSymbolContextList that gets filled in with all of
315  /// the symbol contexts for all the matches.
317  FindCompileUnits(const lldb::SBFileSpec &sb_file_spec);
318 
319  lldb::ByteOrder GetByteOrder();
320 
321  uint32_t GetAddressByteSize();
322 
323  const char *GetTriple();
324 
325  /// Architecture data byte width accessor
326  ///
327  /// \return
328  /// The size in 8-bit (host) bytes of a minimum addressable
329  /// unit from the Architecture's data bus
330  uint32_t GetDataByteSize();
331 
332  /// Architecture code byte width accessor
333  ///
334  /// \return
335  /// The size in 8-bit (host) bytes of a minimum addressable
336  /// unit from the Architecture's code bus
337  uint32_t GetCodeByteSize();
338 
339  /// Gets the target.max-children-count value
340  /// It should be used to limit the number of
341  /// children of large data structures to be displayed.
342  uint32_t GetMaximumNumberOfChildrenToDisplay() const;
343 
344  /// Set the base load address for a module section.
345  ///
346  /// \param[in] section
347  /// The section whose base load address will be set within this
348  /// target.
349  ///
350  /// \param[in] section_base_addr
351  /// The base address for the section.
352  ///
353  /// \return
354  /// An error to indicate success, fail, and any reason for
355  /// failure.
356  lldb::SBError SetSectionLoadAddress(lldb::SBSection section,
357  lldb::addr_t section_base_addr);
358 
359  /// Clear the base load address for a module section.
360  ///
361  /// \param[in] section
362  /// The section whose base load address will be cleared within
363  /// this target.
364  ///
365  /// \return
366  /// An error to indicate success, fail, and any reason for
367  /// failure.
368  lldb::SBError ClearSectionLoadAddress(lldb::SBSection section);
369 
370  /// Slide all file addresses for all module sections so that \a module
371  /// appears to loaded at these slide addresses.
372  ///
373  /// When you need all sections within a module to be loaded at a
374  /// rigid slide from the addresses found in the module object file,
375  /// this function will allow you to easily and quickly slide all
376  /// module sections.
377  ///
378  /// \param[in] module
379  /// The module to load.
380  ///
381  /// \param[in] sections_offset
382  /// An offset that will be applied to all section file addresses
383  /// (the virtual addresses found in the object file itself).
384  ///
385  /// \return
386  /// An error to indicate success, fail, and any reason for
387  /// failure.
388  lldb::SBError SetModuleLoadAddress(lldb::SBModule module,
389  int64_t sections_offset);
390 
391  /// Clear the section base load addresses for all sections in a module.
392  ///
393  /// \param[in] module
394  /// The module to unload.
395  ///
396  /// \return
397  /// An error to indicate success, fail, and any reason for
398  /// failure.
399  lldb::SBError ClearModuleLoadAddress(lldb::SBModule module);
400 
401  /// Find functions by name.
402  ///
403  /// \param[in] name
404  /// The name of the function we are looking for.
405  ///
406  /// \param[in] name_type_mask
407  /// A logical OR of one or more FunctionNameType enum bits that
408  /// indicate what kind of names should be used when doing the
409  /// lookup. Bits include fully qualified names, base names,
410  /// C++ methods, or ObjC selectors.
411  /// See FunctionNameType for more details.
412  ///
413  /// \return
414  /// A lldb::SBSymbolContextList that gets filled in with all of
415  /// the symbol contexts for all the matches.
417  FindFunctions(const char *name,
418  uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
419 
420  /// Find global and static variables by name.
421  ///
422  /// \param[in] name
423  /// The name of the global or static variable we are looking
424  /// for.
425  ///
426  /// \param[in] max_matches
427  /// Allow the number of matches to be limited to \a max_matches.
428  ///
429  /// \return
430  /// A list of matched variables in an SBValueList.
431  lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches);
432 
433  /// Find the first global (or static) variable by name.
434  ///
435  /// \param[in] name
436  /// The name of the global or static variable we are looking
437  /// for.
438  ///
439  /// \return
440  /// An SBValue that gets filled in with the found variable (if any).
441  lldb::SBValue FindFirstGlobalVariable(const char *name);
442 
443  /// Find global and static variables by pattern.
444  ///
445  /// \param[in] name
446  /// The pattern to search for global or static variables
447  ///
448  /// \param[in] max_matches
449  /// Allow the number of matches to be limited to \a max_matches.
450  ///
451  /// \param[in] matchtype
452  /// The match type to use.
453  ///
454  /// \return
455  /// A list of matched variables in an SBValueList.
456  lldb::SBValueList FindGlobalVariables(const char *name, uint32_t max_matches,
457  MatchType matchtype);
458 
459  /// Find global functions by their name with pattern matching.
460  ///
461  /// \param[in] name
462  /// The pattern to search for global or static variables
463  ///
464  /// \param[in] max_matches
465  /// Allow the number of matches to be limited to \a max_matches.
466  ///
467  /// \param[in] matchtype
468  /// The match type to use.
469  ///
470  /// \return
471  /// A list of matched variables in an SBValueList.
472  lldb::SBSymbolContextList FindGlobalFunctions(const char *name,
473  uint32_t max_matches,
474  MatchType matchtype);
475 
476  void Clear();
477 
478  /// Resolve a current file address into a section offset address.
479  ///
480  /// \param[in] file_addr
481  /// The file address to resolve.
482  ///
483  /// \return
484  /// An SBAddress which will be valid if...
485  lldb::SBAddress ResolveFileAddress(lldb::addr_t file_addr);
486 
487  /// Resolve a current load address into a section offset address.
488  ///
489  /// \param[in] vm_addr
490  /// A virtual address from the current process state that is to
491  /// be translated into a section offset address.
492  ///
493  /// \return
494  /// An SBAddress which will be valid if \a vm_addr was
495  /// successfully resolved into a section offset address, or an
496  /// invalid SBAddress if \a vm_addr doesn't resolve to a section
497  /// in a module.
498  lldb::SBAddress ResolveLoadAddress(lldb::addr_t vm_addr);
499 
500  /// Resolve a current load address into a section offset address
501  /// using the process stop ID to identify a time in the past.
502  ///
503  /// \param[in] stop_id
504  /// Each time a process stops, the process stop ID integer gets
505  /// incremented. These stop IDs are used to identify past times
506  /// and can be used in history objects as a cheap way to store
507  /// the time at which the sample was taken. Specifying
508  /// UINT32_MAX will always resolve the address using the
509  /// currently loaded sections.
510  ///
511  /// \param[in] vm_addr
512  /// A virtual address from the current process state that is to
513  /// be translated into a section offset address.
514  ///
515  /// \return
516  /// An SBAddress which will be valid if \a vm_addr was
517  /// successfully resolved into a section offset address, or an
518  /// invalid SBAddress if \a vm_addr doesn't resolve to a section
519  /// in a module.
520  lldb::SBAddress ResolvePastLoadAddress(uint32_t stop_id,
521  lldb::addr_t vm_addr);
522 
523  SBSymbolContext ResolveSymbolContextForAddress(const SBAddress &addr,
524  uint32_t resolve_scope);
525 
526  /// Read target memory. If a target process is running then memory
527  /// is read from here. Otherwise the memory is read from the object
528  /// files. For a target whose bytes are sized as a multiple of host
529  /// bytes, the data read back will preserve the target's byte order.
530  ///
531  /// \param[in] addr
532  /// A target address to read from.
533  ///
534  /// \param[out] buf
535  /// The buffer to read memory into.
536  ///
537  /// \param[in] size
538  /// The maximum number of host bytes to read in the buffer passed
539  /// into this call
540  ///
541  /// \param[out] error
542  /// Status information is written here if the memory read fails.
543  ///
544  /// \return
545  /// The amount of data read in host bytes.
546  size_t ReadMemory(const SBAddress addr, void *buf, size_t size,
548 
549  lldb::SBBreakpoint BreakpointCreateByLocation(const char *file,
550  uint32_t line);
551 
553  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line);
554 
556  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
557  lldb::addr_t offset);
558 
560  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
561  lldb::addr_t offset, SBFileSpecList &module_list);
562 
564  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
565  uint32_t column, lldb::addr_t offset,
566  SBFileSpecList &module_list);
567 
569  BreakpointCreateByLocation(const lldb::SBFileSpec &file_spec, uint32_t line,
570  uint32_t column, lldb::addr_t offset,
571  SBFileSpecList &module_list,
572  bool move_to_nearest_code);
573 
574  lldb::SBBreakpoint BreakpointCreateByName(const char *symbol_name,
575  const char *module_name = nullptr);
576 
577  // This version uses name_type_mask = eFunctionNameTypeAuto
579  BreakpointCreateByName(const char *symbol_name,
580  const SBFileSpecList &module_list,
581  const SBFileSpecList &comp_unit_list);
582 
583  lldb::SBBreakpoint BreakpointCreateByName(
584  const char *symbol_name,
585  uint32_t
586  name_type_mask, // Logical OR one or more FunctionNameType enum bits
587  const SBFileSpecList &module_list,
588  const SBFileSpecList &comp_unit_list);
589 
590  lldb::SBBreakpoint BreakpointCreateByName(
591  const char *symbol_name,
592  uint32_t
593  name_type_mask, // Logical OR one or more FunctionNameType enum bits
594  lldb::LanguageType symbol_language,
595  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
596 
597  lldb::SBBreakpoint BreakpointCreateByNames(
598  const char *symbol_name[], uint32_t num_names,
599  uint32_t
600  name_type_mask, // Logical OR one or more FunctionNameType enum bits
601  const SBFileSpecList &module_list,
602  const SBFileSpecList &comp_unit_list);
603 
604  lldb::SBBreakpoint BreakpointCreateByNames(
605  const char *symbol_name[], uint32_t num_names,
606  uint32_t
607  name_type_mask, // Logical OR one or more FunctionNameType enum bits
608  lldb::LanguageType symbol_language,
609  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
610 
611  lldb::SBBreakpoint BreakpointCreateByNames(
612  const char *symbol_name[], uint32_t num_names,
613  uint32_t
614  name_type_mask, // Logical OR one or more FunctionNameType enum bits
615  lldb::LanguageType symbol_language,
616  lldb::addr_t offset, const SBFileSpecList &module_list,
617  const SBFileSpecList &comp_unit_list);
618 
619  lldb::SBBreakpoint BreakpointCreateByRegex(const char *symbol_name_regex,
620  const char *module_name = nullptr);
621 
623  BreakpointCreateByRegex(const char *symbol_name_regex,
624  const SBFileSpecList &module_list,
625  const SBFileSpecList &comp_unit_list);
626 
627  lldb::SBBreakpoint BreakpointCreateByRegex(
628  const char *symbol_name_regex, lldb::LanguageType symbol_language,
629  const SBFileSpecList &module_list, const SBFileSpecList &comp_unit_list);
630 
632  BreakpointCreateBySourceRegex(const char *source_regex,
633  const SBFileSpec &source_file,
634  const char *module_name = nullptr);
635 
637  BreakpointCreateBySourceRegex(const char *source_regex,
638  const SBFileSpecList &module_list,
639  const SBFileSpecList &source_file);
640 
641  lldb::SBBreakpoint BreakpointCreateBySourceRegex(
642  const char *source_regex, const SBFileSpecList &module_list,
643  const SBFileSpecList &source_file, const SBStringList &func_names);
644 
645  lldb::SBBreakpoint BreakpointCreateForException(lldb::LanguageType language,
646  bool catch_bp, bool throw_bp);
647 
648  lldb::SBBreakpoint BreakpointCreateByAddress(addr_t address);
649 
650  lldb::SBBreakpoint BreakpointCreateBySBAddress(SBAddress &address);
651 
652  /// Create a breakpoint using a scripted resolver.
653  ///
654  /// \param[in] class_name
655  /// This is the name of the class that implements a scripted resolver.
656  ///
657  /// \param[in] extra_args
658  /// This is an SBStructuredData object that will get passed to the
659  /// constructor of the class in class_name. You can use this to
660  /// reuse the same class, parametrizing with entries from this
661  /// dictionary.
662  ///
663  /// \param module_list
664  /// If this is non-empty, this will be used as the module filter in the
665  /// SearchFilter created for this breakpoint.
666  ///
667  /// \param file_list
668  /// If this is non-empty, this will be used as the comp unit filter in the
669  /// SearchFilter created for this breakpoint.
670  ///
671  /// \return
672  /// An SBBreakpoint that will set locations based on the logic in the
673  /// resolver's search callback.
674  lldb::SBBreakpoint BreakpointCreateFromScript(
675  const char *class_name,
676  SBStructuredData &extra_args,
677  const SBFileSpecList &module_list,
678  const SBFileSpecList &file_list,
679  bool request_hardware = false);
680 
681  /// Read breakpoints from source_file and return the newly created
682  /// breakpoints in bkpt_list.
683  ///
684  /// \param[in] source_file
685  /// The file from which to read the breakpoints.
686  ///
687  /// \param[out] new_bps
688  /// A list of the newly created breakpoints.
689  ///
690  /// \return
691  /// An SBError detailing any errors in reading in the breakpoints.
692  lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
693  SBBreakpointList &new_bps);
694 
695  /// Read breakpoints from source_file and return the newly created
696  /// breakpoints in bkpt_list.
697  ///
698  /// \param[in] source_file
699  /// The file from which to read the breakpoints.
700  ///
701  /// \param[in] matching_names
702  /// Only read in breakpoints whose names match one of the names in this
703  /// list.
704  ///
705  /// \param[out] new_bps
706  /// A list of the newly created breakpoints.
707  ///
708  /// \return
709  /// An SBError detailing any errors in reading in the breakpoints.
710  lldb::SBError BreakpointsCreateFromFile(SBFileSpec &source_file,
711  SBStringList &matching_names,
712  SBBreakpointList &new_bps);
713 
714  /// Write breakpoints to dest_file.
715  ///
716  /// \param[in] dest_file
717  /// The file to which to write the breakpoints.
718  ///
719  /// \return
720  /// An SBError detailing any errors in writing in the breakpoints.
721  lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file);
722 
723  /// Write breakpoints listed in bkpt_list to dest_file.
724  ///
725  /// \param[in] dest_file
726  /// The file to which to write the breakpoints.
727  ///
728  /// \param[in] bkpt_list
729  /// Only write breakpoints from this list.
730  ///
731  /// \param[in] append
732  /// If \b true, append the breakpoints in bkpt_list to the others
733  /// serialized in dest_file. If dest_file doesn't exist, then a new
734  /// file will be created and the breakpoints in bkpt_list written to it.
735  ///
736  /// \return
737  /// An SBError detailing any errors in writing in the breakpoints.
738  lldb::SBError BreakpointsWriteToFile(SBFileSpec &dest_file,
739  SBBreakpointList &bkpt_list,
740  bool append = false);
741 
742  uint32_t GetNumBreakpoints() const;
743 
744  lldb::SBBreakpoint GetBreakpointAtIndex(uint32_t idx) const;
745 
746  bool BreakpointDelete(break_id_t break_id);
747 
748  lldb::SBBreakpoint FindBreakpointByID(break_id_t break_id);
749 
750  // Finds all breakpoints by name, returning the list in bkpt_list. Returns
751  // false if the name is not a valid breakpoint name, true otherwise.
752  bool FindBreakpointsByName(const char *name, SBBreakpointList &bkpt_list);
753 
754  void GetBreakpointNames(SBStringList &names);
755 
756  void DeleteBreakpointName(const char *name);
757 
758  bool EnableAllBreakpoints();
759 
760  bool DisableAllBreakpoints();
761 
762  bool DeleteAllBreakpoints();
763 
764  uint32_t GetNumWatchpoints() const;
765 
766  lldb::SBWatchpoint GetWatchpointAtIndex(uint32_t idx) const;
767 
768  bool DeleteWatchpoint(lldb::watch_id_t watch_id);
769 
770  lldb::SBWatchpoint FindWatchpointByID(lldb::watch_id_t watch_id);
771 
772  lldb::SBWatchpoint WatchAddress(lldb::addr_t addr, size_t size, bool read,
773  bool write, SBError &error);
774 
775  bool EnableAllWatchpoints();
776 
777  bool DisableAllWatchpoints();
778 
779  bool DeleteAllWatchpoints();
780 
781  lldb::SBBroadcaster GetBroadcaster() const;
782 
783  lldb::SBType FindFirstType(const char *type);
784 
785  lldb::SBTypeList FindTypes(const char *type);
786 
787  lldb::SBType GetBasicType(lldb::BasicType type);
788 
789  lldb::SBValue CreateValueFromAddress(const char *name, lldb::SBAddress addr,
790  lldb::SBType type);
791 
792  lldb::SBValue CreateValueFromData(const char *name, lldb::SBData data,
793  lldb::SBType type);
794 
795  lldb::SBValue CreateValueFromExpression(const char *name, const char *expr);
796 
797  SBSourceManager GetSourceManager();
798 
799  lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
800  uint32_t count);
801 
802  lldb::SBInstructionList ReadInstructions(lldb::SBAddress base_addr,
803  uint32_t count,
804  const char *flavor_string);
805 
806  lldb::SBInstructionList GetInstructions(lldb::SBAddress base_addr,
807  const void *buf, size_t size);
808 
809  // The "WithFlavor" is necessary to keep SWIG from getting confused about
810  // overloaded arguments when using the buf + size -> Python Object magic.
811 
812  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::SBAddress base_addr,
813  const char *flavor_string,
814  const void *buf,
815  size_t size);
816 
817  lldb::SBInstructionList GetInstructions(lldb::addr_t base_addr,
818  const void *buf, size_t size);
819 
820  lldb::SBInstructionList GetInstructionsWithFlavor(lldb::addr_t base_addr,
821  const char *flavor_string,
822  const void *buf,
823  size_t size);
824 
825  lldb::SBSymbolContextList FindSymbols(const char *name,
827 
828  bool operator==(const lldb::SBTarget &rhs) const;
829 
830  bool operator!=(const lldb::SBTarget &rhs) const;
831 
832  bool GetDescription(lldb::SBStream &description,
833  lldb::DescriptionLevel description_level);
834 
835  lldb::SBValue EvaluateExpression(const char *expr);
836 
837  lldb::SBValue EvaluateExpression(const char *expr,
838  const SBExpressionOptions &options);
839 
840  lldb::addr_t GetStackRedZoneSize();
841 
842  bool IsLoaded(const lldb::SBModule &module) const;
843 
844  lldb::SBLaunchInfo GetLaunchInfo() const;
845 
846  void SetLaunchInfo(const lldb::SBLaunchInfo &launch_info);
847 
848  /// Get a \a SBTrace object the can manage the processor trace information of
849  /// this target.
850  ///
851  /// \return
852  /// The trace object. The returned SBTrace object might not be valid, so it
853  /// should be checked with a call to "bool SBTrace::IsValid()".
854  lldb::SBTrace GetTrace();
855 
856  /// Create a \a Trace object for the current target using the using the
857  /// default supported tracing technology for this process.
858  ///
859  /// \param[out] error
860  /// An error if a Trace already exists or the trace couldn't be created.
861  lldb::SBTrace CreateTrace(SBError &error);
862 
863 protected:
864  friend class SBAddress;
865  friend class SBBlock;
866  friend class SBBreakpointList;
867  friend class SBBreakpointNameImpl;
868  friend class SBDebugger;
869  friend class SBExecutionContext;
870  friend class SBFunction;
871  friend class SBInstruction;
872  friend class SBModule;
873  friend class SBPlatform;
874  friend class SBProcess;
875  friend class SBSection;
876  friend class SBSourceManager;
877  friend class SBSymbol;
878  friend class SBValue;
879  friend class SBVariablesOptions;
880 
881  // Constructors are private, use static Target::Create function to create an
882  // instance of this class.
883 
884  lldb::TargetSP GetSP() const;
885 
886  void SetSP(const lldb::TargetSP &target_sp);
887 
888 private:
889  lldb::TargetSP m_opaque_sp;
890 };
891 
892 } // namespace lldb
893 
894 #endif // LLDB_API_SBTARGET_H
lldb::SBValueList
Definition: SBValueList.h:18
lldb::SBStringList
Definition: SBStringList.h:16
lldb::SBLaunchInfo
Definition: SBLaunchInfo.h:23
lldb::SBVariablesOptions
Definition: SBVariablesOptions.h:19
lldb::SBModuleSpec
Definition: SBModuleSpec.h:17
SBDefines.h
lldb::MatchType
MatchType
String matching algorithm used by SBTarget.
Definition: lldb-enumerations.h:1032
SBLaunchInfo.h
lldb::SBError
Definition: SBError.h:20
lldb::SBValue
Definition: SBValue.h:21
SBFileSpecList.h
lldb::SBSymbol
Definition: SBSymbol.h:19
lldb::SBSymbolContextList
Definition: SBSymbolContextList.h:17
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb::SBEvent
Definition: SBEvent.h:21
lldb::SBProcess
Definition: SBProcess.h:23
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb::BasicType
BasicType
Basic types enumeration for the public API SBType::GetBasicType().
Definition: lldb-enumerations.h:741
SBWatchpoint.h
SBSymbolContextList.h
lldb::SBExecutionContext
Definition: SBExecutionContext.h:20
lldb::SBInstructionList
Definition: SBInstructionList.h:18
lldb::SBTrace
Definition: SBTrace.h:19
lldb::SBTarget
Definition: SBTarget.h:29
error
static llvm::raw_ostream & error(Stream &strm)
Definition: CommandReturnObject.cpp:17
lldb::eSymbolTypeAny
@ eSymbolTypeAny
Definition: lldb-enumerations.h:613
lldb::SBDebugger
Definition: SBDebugger.h:34
SBFileSpec.h
lldb::SBBlock
Definition: SBBlock.h:19
lldb::break_id_t
int32_t break_id_t
Definition: lldb-types.h:88
SBBroadcaster.h
SBAttachInfo.h
lldb::operator==
bool LLDB_API operator==(const SBAddress &lhs, const SBAddress &rhs)
Definition: SBAddress.cpp:63
lldb::SBFunction
Definition: SBFunction.h:18
lldb::SBEnvironment
Definition: SBEnvironment.h:16
lldb::SBSection
Definition: SBSection.h:17
lldb::watch_id_t
int32_t watch_id_t
Definition: lldb-types.h:89
lldb::SBBreakpointNameImpl
Definition: SBBreakpointName.cpp:35
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:612
lldb::SBBreakpointList
Definition: SBBreakpoint.h:159
SBAddress.h
lldb_private::operator!=
bool operator!=(const Address &lhs, const Address &rhs)
Definition: Address.cpp:1005
lldb::SBType
Definition: SBType.h:104
SBType.h
lldb::SBTypeList
Definition: SBType.h:241
lldb::SBWatchpoint
Definition: SBWatchpoint.h:16
lldb::SBExpressionOptions
Definition: SBExpressionOptions.h:18
lldb::SBListener
Definition: SBListener.h:16
lldb::SBSymbolContext
Definition: SBSymbolContext.h:22
uint32_t
lldb::SBTarget::m_opaque_sp
lldb::TargetSP m_opaque_sp
Definition: SBTarget.h:889
lldb::SBStructuredData
Definition: SBStructuredData.h:17
lldb::SBBreakpoint
Definition: SBBreakpoint.h:18
lldb::pid_t
uint64_t pid_t
Definition: lldb-types.h:85
lldb::SBTarget
class LLDB_API SBTarget
Definition: SBDefines.h:84
lldb::SBModule
Definition: SBModule.h:20
lldb::SBData
Definition: SBData.h:20
SBValue.h
lldb::SBInstruction
Definition: SBInstruction.h:24
lldb::SBFileSpec
Definition: SBFileSpec.h:16
lldb::SBAddress
Definition: SBAddress.h:17
lldb::SBBroadcaster
Definition: SBBroadcaster.h:16
lldb::SBStream
Definition: SBStream.h:18
lldb::SBPlatform
Definition: SBPlatform.h:93
lldb::SBAttachInfo
Definition: SBAttachInfo.h:18
lldb
Definition: SBAddress.h:15
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb::SBFileSpecList
Definition: SBFileSpecList.h:17
SBBreakpoint.h
lldb::ByteOrder
ByteOrder
Byte ordering definitions.
Definition: lldb-enumerations.h:138
LLDB_API
#define LLDB_API
Definition: SBDefines.h:25
lldb::SBSourceManager
Definition: SBSourceManager.h:18