From 9e6d35490a6542f9c97607f93c2ef8ca8e03cbcc Mon Sep 17 00:00:00 2001 From: Dimitry Andric Date: Wed, 6 Jan 2016 20:12:03 +0000 Subject: Vendor import of lldb trunk r256945: https://llvm.org/svn/llvm-project/lldb/trunk@256945 --- www/cpp_reference/html/SBModule_8h_source.html | 332 +++++++++++++++++++++++++ 1 file changed, 332 insertions(+) create mode 100644 www/cpp_reference/html/SBModule_8h_source.html (limited to 'www/cpp_reference/html/SBModule_8h_source.html') diff --git a/www/cpp_reference/html/SBModule_8h_source.html b/www/cpp_reference/html/SBModule_8h_source.html new file mode 100644 index 000000000000..9867ae49940c --- /dev/null +++ b/www/cpp_reference/html/SBModule_8h_source.html @@ -0,0 +1,332 @@ + + + + + +LLVM: SBModule.h Source File + + +

LLDB API Documentation

+ + + + + +
+
+
SBModule.h
+
+
+Go to the documentation of this file.
1 //===-- SBModule.h ----------------------------------------------*- C++ -*-===//
+
2 //
+
3 // The LLVM Compiler Infrastructure
+
4 //
+
5 // This file is distributed under the University of Illinois Open Source
+
6 // License. See LICENSE.TXT for details.
+
7 //
+
8 //===----------------------------------------------------------------------===//
+
9 
+
10 #ifndef LLDB_SBModule_h_
+
11 #define LLDB_SBModule_h_
+
12 
+
13 #include "lldb/API/SBDefines.h"
+
14 #include "lldb/API/SBError.h"
+
15 #include "lldb/API/SBSection.h"
+
16 #include "lldb/API/SBSymbolContext.h"
+
17 #include "lldb/API/SBValueList.h"
+
18 
+
19 namespace lldb {
+
20 
+
21 class SBModule
+
22 {
+
23 public:
+
24 
+
25  SBModule ();
+
26 
+
27  SBModule (const SBModule &rhs);
+
28 
+
29  SBModule (const SBModuleSpec &module_spec);
+
30 
+
31  const SBModule &
+
32  operator = (const SBModule &rhs);
+
33 
+
34  SBModule (lldb::SBProcess &process,
+
35  lldb::addr_t header_addr);
+
36 
+
37  ~SBModule ();
+
38 
+
39  bool
+
40  IsValid () const;
+
41 
+
42  void
+
43  Clear();
+
44 
+
45  //------------------------------------------------------------------
+
46  /// Get const accessor for the module file specification.
+
47  ///
+
48  /// This function returns the file for the module on the host system
+
49  /// that is running LLDB. This can differ from the path on the
+
50  /// platform since we might be doing remote debugging.
+
51  ///
+
52  /// @return
+
53  /// A const reference to the file specification object.
+
54  //------------------------------------------------------------------
+
55  lldb::SBFileSpec
+
56  GetFileSpec () const;
+
57 
+
58  //------------------------------------------------------------------
+
59  /// Get accessor for the module platform file specification.
+
60  ///
+
61  /// Platform file refers to the path of the module as it is known on
+
62  /// the remote system on which it is being debugged. For local
+
63  /// debugging this is always the same as Module::GetFileSpec(). But
+
64  /// remote debugging might mention a file '/usr/lib/liba.dylib'
+
65  /// which might be locally downloaded and cached. In this case the
+
66  /// platform file could be something like:
+
67  /// '/tmp/lldb/platform-cache/remote.host.computer/usr/lib/liba.dylib'
+
68  /// The file could also be cached in a local developer kit directory.
+
69  ///
+
70  /// @return
+
71  /// A const reference to the file specification object.
+
72  //------------------------------------------------------------------
+
73  lldb::SBFileSpec
+
74  GetPlatformFileSpec () const;
+
75 
+
76  bool
+
77  SetPlatformFileSpec (const lldb::SBFileSpec &platform_file);
+
78 
+
79  lldb::ByteOrder
+
80  GetByteOrder ();
+
81 
+
82  uint32_t
+
83  GetAddressByteSize();
+
84 
+
85  const char *
+
86  GetTriple ();
+
87 
+
88  const uint8_t *
+
89  GetUUIDBytes () const;
+
90 
+
91  const char *
+
92  GetUUIDString () const;
+
93 
+
94  bool
+
95  operator == (const lldb::SBModule &rhs) const;
+
96 
+
97  bool
+
98  operator != (const lldb::SBModule &rhs) const;
+
99 
+
100  lldb::SBSection
+
101  FindSection (const char *sect_name);
+
102 
+
103  lldb::SBAddress
+
104  ResolveFileAddress (lldb::addr_t vm_addr);
+
105 
+
106  lldb::SBSymbolContext
+
107  ResolveSymbolContextForAddress (const lldb::SBAddress& addr,
+
108  uint32_t resolve_scope);
+
109 
+
110  bool
+
111  GetDescription (lldb::SBStream &description);
+
112 
+
113  uint32_t
+
114  GetNumCompileUnits();
+
115 
+
116  lldb::SBCompileUnit
+
117  GetCompileUnitAtIndex (uint32_t);
+
118 
+
119  size_t
+
120  GetNumSymbols ();
+
121 
+
122  lldb::SBSymbol
+
123  GetSymbolAtIndex (size_t idx);
+
124 
+
125  lldb::SBSymbol
+
126  FindSymbol (const char *name,
+
127  lldb::SymbolType type = eSymbolTypeAny);
+
128 
+
129  lldb::SBSymbolContextList
+
130  FindSymbols (const char *name,
+
131  lldb::SymbolType type = eSymbolTypeAny);
+
132 
+
133  size_t
+
134  GetNumSections ();
+
135 
+
136  lldb::SBSection
+
137  GetSectionAtIndex (size_t idx);
+
138  //------------------------------------------------------------------
+
139  /// Find functions by name.
+
140  ///
+
141  /// @param[in] name
+
142  /// The name of the function we are looking for.
+
143  ///
+
144  /// @param[in] name_type_mask
+
145  /// A logical OR of one or more FunctionNameType enum bits that
+
146  /// indicate what kind of names should be used when doing the
+
147  /// lookup. Bits include fully qualified names, base names,
+
148  /// C++ methods, or ObjC selectors.
+
149  /// See FunctionNameType for more details.
+
150  ///
+
151  /// @return
+
152  /// A lldb::SBSymbolContextList that gets filled in with all of
+
153  /// the symbol contexts for all the matches.
+
154  //------------------------------------------------------------------
+
155  lldb::SBSymbolContextList
+
156  FindFunctions (const char *name,
+
157  uint32_t name_type_mask = lldb::eFunctionNameTypeAny);
+
158 
+
159  //------------------------------------------------------------------
+
160  /// Find global and static variables by name.
+
161  ///
+
162  /// @param[in] target
+
163  /// A valid SBTarget instance representing the debuggee.
+
164  ///
+
165  /// @param[in] name
+
166  /// The name of the global or static variable we are looking
+
167  /// for.
+
168  ///
+
169  /// @param[in] max_matches
+
170  /// Allow the number of matches to be limited to \a max_matches.
+
171  ///
+
172  /// @return
+
173  /// A list of matched variables in an SBValueList.
+
174  //------------------------------------------------------------------
+
175  lldb::SBValueList
+
176  FindGlobalVariables (lldb::SBTarget &target,
+
177  const char *name,
+
178  uint32_t max_matches);
+
179 
+
180  //------------------------------------------------------------------
+
181  /// Find the first global (or static) variable by name.
+
182  ///
+
183  /// @param[in] target
+
184  /// A valid SBTarget instance representing the debuggee.
+
185  ///
+
186  /// @param[in] name
+
187  /// The name of the global or static variable we are looking
+
188  /// for.
+
189  ///
+
190  /// @return
+
191  /// An SBValue that gets filled in with the found variable (if any).
+
192  //------------------------------------------------------------------
+
193  lldb::SBValue
+
194  FindFirstGlobalVariable (lldb::SBTarget &target, const char *name);
+
195 
+
196  lldb::SBType
+
197  FindFirstType (const char* name);
+
198 
+
199  lldb::SBTypeList
+
200  FindTypes (const char* type);
+
201 
+
202  lldb::SBType
+
203  GetBasicType(lldb::BasicType type);
+
204 
+
205  //------------------------------------------------------------------
+
206  /// Get all types matching \a type_mask from debug info in this
+
207  /// module.
+
208  ///
+
209  /// @param[in] type_mask
+
210  /// A bitfield that consists of one or more bits logically OR'ed
+
211  /// together from the lldb::TypeClass enumeration. This allows
+
212  /// you to request only structure types, or only class, struct
+
213  /// and union types. Passing in lldb::eTypeClassAny will return
+
214  /// all types found in the debug information for this module.
+
215  ///
+
216  /// @return
+
217  /// A list of types in this module that match \a type_mask
+
218  //------------------------------------------------------------------
+
219  lldb::SBTypeList
+
220  GetTypes (uint32_t type_mask = lldb::eTypeClassAny);
+
221 
+
222  //------------------------------------------------------------------
+
223  /// Get the module version numbers.
+
224  ///
+
225  /// Many object files have a set of version numbers that describe
+
226  /// the version of the executable or shared library. Typically there
+
227  /// are major, minor and build, but there may be more. This function
+
228  /// will extract the versions from object files if they are available.
+
229  ///
+
230  /// If \a versions is NULL, or if \a num_versions is 0, the return
+
231  /// value will indicate how many version numbers are available in
+
232  /// this object file. Then a subsequent call can be made to this
+
233  /// function with a value of \a versions and \a num_versions that
+
234  /// has enough storage to store some or all version numbers.
+
235  ///
+
236  /// @param[out] versions
+
237  /// A pointer to an array of uint32_t types that is \a num_versions
+
238  /// long. If this value is NULL, the return value will indicate
+
239  /// how many version numbers are required for a subsequent call
+
240  /// to this function so that all versions can be retrieved. If
+
241  /// the value is non-NULL, then at most \a num_versions of the
+
242  /// existing versions numbers will be filled into \a versions.
+
243  /// If there is no version information available, \a versions
+
244  /// will be filled with \a num_versions UINT32_MAX values
+
245  /// and zero will be returned.
+
246  ///
+
247  /// @param[in] num_versions
+
248  /// The maximum number of entries to fill into \a versions. If
+
249  /// this value is zero, then the return value will indicate
+
250  /// how many version numbers there are in total so another call
+
251  /// to this function can be make with adequate storage in
+
252  /// \a versions to get all of the version numbers. If \a
+
253  /// num_versions is less than the actual number of version
+
254  /// numbers in this object file, only \a num_versions will be
+
255  /// filled into \a versions (if \a versions is non-NULL).
+
256  ///
+
257  /// @return
+
258  /// This function always returns the number of version numbers
+
259  /// that this object file has regardless of the number of
+
260  /// version numbers that were copied into \a versions.
+
261  //------------------------------------------------------------------
+
262  uint32_t
+
263  GetVersion (uint32_t *versions,
+
264  uint32_t num_versions);
+
265 
+
266 private:
+
267  friend class SBAddress;
+
268  friend class SBFrame;
+
269  friend class SBSection;
+
270  friend class SBSymbolContext;
+
271  friend class SBTarget;
+
272 
+
273  explicit SBModule (const lldb::ModuleSP& module_sp);
+
274 
+
275  ModuleSP
+
276  GetSP () const;
+
277 
+
278  void
+
279  SetSP (const ModuleSP &module_sp);
+
280 
+
281  lldb::ModuleSP m_opaque_sp;
+
282 };
+
283 
+
284 
+
285 } // namespace lldb
+
286 
+
287 #endif // LLDB_SBModule_h_
+
+
+

+Generated on Fri Jul 19 2013 13:25:55 for LLVM by +Doxygen1.8.1.2
+Copyright © 2003-2013 University of Illinois at Urbana-Champaign. +All Rights Reserved.

+
+ + + -- cgit v1.2.3