LLDB  mainline
Symbol.h
Go to the documentation of this file.
1 //===-- Symbol.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_SYMBOL_SYMBOL_H
10 #define LLDB_SYMBOL_SYMBOL_H
11 
12 #include "lldb/Core/AddressRange.h"
13 #include "lldb/Core/Mangled.h"
15 #include "lldb/Utility/UserID.h"
16 #include "lldb/lldb-private.h"
17 
18 namespace lldb_private {
19 
20 class Symbol : public SymbolContextScope {
21 public:
22  // ObjectFile readers can classify their symbol table entries and searches
23  // can be made on specific types where the symbol values will have
24  // drastically different meanings and sorting requirements.
25  Symbol();
26 
27  Symbol(uint32_t symID, llvm::StringRef name, lldb::SymbolType type,
28  bool external, bool is_debug, bool is_trampoline, bool is_artificial,
29  const lldb::SectionSP &section_sp, lldb::addr_t value,
30  lldb::addr_t size, bool size_is_valid,
31  bool contains_linker_annotations, uint32_t flags);
32 
33  Symbol(uint32_t symID, const Mangled &mangled, lldb::SymbolType type,
34  bool external, bool is_debug, bool is_trampoline, bool is_artificial,
35  const AddressRange &range, bool size_is_valid,
36  bool contains_linker_annotations, uint32_t flags);
37 
38  Symbol(const Symbol &rhs);
39 
40  const Symbol &operator=(const Symbol &rhs);
41 
42  void Clear();
43 
44  bool Compare(ConstString name, lldb::SymbolType type) const;
45 
46  void Dump(Stream *s, Target *target, uint32_t index,
47  Mangled::NamePreference name_preference =
48  Mangled::ePreferDemangled) const;
49 
50  bool ValueIsAddress() const;
51 
52  // The GetAddressRef() accessor functions should only be called if you
53  // previously call ValueIsAddress() otherwise you might get an reference to
54  // an Address object that contains an constant integer value in
55  // m_addr_range.m_base_addr.m_offset which could be incorrectly used to
56  // represent an absolute address since it has no section.
58 
59  const Address &GetAddressRef() const { return m_addr_range.GetBaseAddress(); }
60 
61  // Makes sure the symbol's value is an address and returns the file address.
62  // Returns LLDB_INVALID_ADDRESS if the symbol's value isn't an address.
64 
65  // Makes sure the symbol's value is an address and gets the load address
66  // using \a target if it is. Returns LLDB_INVALID_ADDRESS if the symbol's
67  // value isn't an address or if the section isn't loaded in \a target.
68  lldb::addr_t GetLoadAddress(Target *target) const;
69 
70  // Access the address value. Do NOT hand out the AddressRange as an object as
71  // the byte size of the address range may not be filled in and it should be
72  // accessed via GetByteSize().
73  Address GetAddress() const {
74  // Make sure the our value is an address before we hand a copy out. We use
75  // the Address inside m_addr_range to contain the value for symbols that
76  // are not address based symbols so we are using it for more than just
77  // addresses. For example undefined symbols on MacOSX have a nlist.n_value
78  // of 0 (zero) and this will get placed into
79  // m_addr_range.m_base_addr.m_offset and it will have no section. So in the
80  // GetAddress() accessor, we need to hand out an invalid address if the
81  // symbol's value isn't an address.
82  if (ValueIsAddress())
84  else
85  return Address();
86  }
87 
88  /// Get the raw value of the symbol from the symbol table.
89  ///
90  /// If the symbol's value is an address, return the file address, else return
91  /// the raw value that is stored in the m_addr_range. If the base address has
92  /// no section, then getting the file address will return the correct value
93  /// as it will return the offset in the base address which is the value.
94  uint64_t GetRawValue() const {
96  }
97 
98  // When a symbol's value isn't an address, we need to access the raw value.
99  // This function will ensure this symbol's value isn't an address and return
100  // the integer value if this checks out, otherwise it will return
101  // "fail_value" if the symbol is an address value.
102  uint64_t GetIntegerValue(uint64_t fail_value = 0) const {
103  if (ValueIsAddress()) {
104  // This symbol's value is an address. Use Symbol::GetAddress() to get the
105  // address.
106  return fail_value;
107  } else {
108  // The value is stored in the base address' offset
110  }
111  }
112 
114 
115  ConstString GetName() const;
116 
118 
119  ConstString GetDisplayName() const;
120 
121  uint32_t GetID() const { return m_uid; }
122 
124  // TODO: See if there is a way to determine the language for a symbol
125  // somehow, for now just return our best guess
126  return GetMangled().GuessLanguage();
127  }
128 
129  void SetID(uint32_t uid) { m_uid = uid; }
130 
131  Mangled &GetMangled() {
133  return m_mangled;
134  }
135 
136  const Mangled &GetMangled() const {
138  return m_mangled;
139  }
140 
142 
144 
146 
147  bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec);
148 
149  Symbol *ResolveReExportedSymbol(Target &target) const;
150 
151  uint32_t GetSiblingIndex() const;
152 
154 
156 
157  const char *GetTypeAsString() const;
158 
159  uint32_t GetFlags() const { return m_flags; }
160 
161  void SetFlags(uint32_t flags) { m_flags = flags; }
162 
164  Target *target) const;
165 
166  bool IsSynthetic() const { return m_is_synthetic; }
167 
169 
170  void SetIsSynthetic(bool b) { m_is_synthetic = b; }
171 
173 
175 
176  bool IsDebug() const { return m_is_debug; }
177 
178  void SetDebug(bool b) { m_is_debug = b; }
179 
180  bool IsExternal() const { return m_is_external; }
181 
182  void SetExternal(bool b) { m_is_external = b; }
183 
184  bool IsTrampoline() const;
185 
186  bool IsIndirect() const;
187 
188  bool IsWeak() const { return m_is_weak; }
189 
190  void SetIsWeak (bool b) { m_is_weak = b; }
191 
192  bool GetByteSizeIsValid() const { return m_size_is_valid; }
193 
194  lldb::addr_t GetByteSize() const;
195 
197  m_size_is_valid = size > 0;
199  }
200 
201  bool GetSizeIsSibling() const { return m_size_is_sibling; }
202 
203  void SetSizeIsSibling(bool b) { m_size_is_sibling = b; }
204 
205  // If m_type is "Code" or "Function" then this will return the prologue size
206  // in bytes, else it will return zero.
208 
211  }
212 
214 
217  }
220  }
221  /// \copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
222  ///
223  /// \see SymbolContextScope
224  void CalculateSymbolContext(SymbolContext *sc) override;
225 
226  lldb::ModuleSP CalculateSymbolContextModule() override;
227 
229 
230  /// \copydoc SymbolContextScope::DumpSymbolContext(Stream*)
231  ///
232  /// \see SymbolContextScope
233  void DumpSymbolContext(Stream *s) override;
234 
235  lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx,
236  const char *flavor,
237  bool prefer_file_cache);
238 
239  bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor,
240  bool prefer_file_cache, Stream &strm);
241 
242  bool ContainsFileAddress(lldb::addr_t file_addr) const;
243 
244  static llvm::StringRef GetSyntheticSymbolPrefix() {
245  return "___lldb_unnamed_symbol";
246  }
247 
248  /// Decode a serialized version of this object from data.
249  ///
250  /// \param data
251  /// The decoder object that references the serialized data.
252  ///
253  /// \param offset_ptr
254  /// A pointer that contains the offset from which the data will be decoded
255  /// from that gets updated as data gets decoded.
256  ///
257  /// \param section_list
258  /// A section list that allows lldb_private::Address objects to be filled
259  /// in. The address information for symbols are serilized as file addresses
260  /// and must be converted into Address objects with the right section and
261  /// offset.
262  ///
263  /// \param strtab
264  /// All strings in cache files are put into string tables for efficiency
265  /// and cache file size reduction. Strings are stored as uint32_t string
266  /// table offsets in the cache data.
267  ///
268  /// \return
269  /// True if the symbol is successfully decoded, false otherwise.
270  bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr,
271  const SectionList *section_list, const StringTableReader &strtab);
272 
273  /// Encode this object into a data encoder object.
274  ///
275  /// This allows this object to be serialized to disk.
276  ///
277  /// \param encoder
278  /// A data encoder object that serialized bytes will be encoded into.
279  ///
280  /// \param strtab
281  /// All strings in cache files are put into string tables for efficiency
282  /// and cache file size reduction. Strings are stored as uint32_t string
283  /// table offsets in the cache data.
284  void Encode(DataEncoder &encoder, ConstStringTable &strtab) const;
285 
286  bool operator==(const Symbol &rhs) const;
287 
288 protected:
289  // This is the internal guts of ResolveReExportedSymbol, it assumes
290  // reexport_name is not null, and that module_spec is valid. We track the
291  // modules we've already seen to make sure we don't get caught in a cycle.
292 
294  Target &target, ConstString &reexport_name,
295  lldb_private::ModuleSpec &module_spec,
296  lldb_private::ModuleList &seen_modules) const;
297 
298  void SynthesizeNameIfNeeded() const;
299 
301  UINT32_MAX; // User ID (usually the original symbol table index)
302  uint16_t m_type_data = 0; // data specific to m_type
303  uint16_t m_type_data_resolved : 1, // True if the data in m_type_data has
304  // already been calculated
305  m_is_synthetic : 1, // non-zero if this symbol is not actually in the
306  // symbol table, but synthesized from other info in
307  // the object file.
308  m_is_debug : 1, // non-zero if this symbol is debug information in a
309  // symbol
310  m_is_external : 1, // non-zero if this symbol is globally visible
311  m_size_is_sibling : 1, // m_size contains the index of this symbol's
312  // sibling
313  m_size_is_synthesized : 1, // non-zero if this symbol's size was
314  // calculated using a delta between this
315  // symbol and the next
317  m_demangled_is_synthesized : 1, // The demangled name was created should
318  // not be used for expressions or other
319  // lookups
320  m_contains_linker_annotations : 1, // The symbol name contains linker
321  // annotations, which are optional when
322  // doing name lookups
324  m_type : 6; // Values from the lldb::SymbolType enum.
325  mutable Mangled m_mangled; // uniqued symbol name/mangled name pair
326  AddressRange m_addr_range; // Contains the value, or the section offset
327  // address when the value is an address in a
328  // section, and the size (if any)
329  uint32_t m_flags = 0; // A copy of the flags from the original symbol table,
330  // the ObjectFile plug-in can interpret these
331 };
332 
333 } // namespace lldb_private
334 
335 #endif // LLDB_SYMBOL_SYMBOL_H
lldb_private::Symbol::SetDebug
void SetDebug(bool b)
Definition: Symbol.h:178
lldb_private::AddressRange::GetBaseAddress
Address & GetBaseAddress()
Get accessor for the base address of the range.
Definition: AddressRange.h:209
lldb_private::ExecutionContext
Definition: ExecutionContext.h:292
lldb_private::Symbol::m_type
uint16_t m_type
Definition: Symbol.h:324
Mangled.h
lldb_private::Symbol::Encode
void Encode(DataEncoder &encoder, ConstStringTable &strtab) const
Encode this object into a data encoder object.
Definition: Symbol.cpp:652
lldb_private::StringTableReader
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:212
lldb_private::Symbol::Decode
bool Decode(const DataExtractor &data, lldb::offset_t *offset_ptr, const SectionList *section_list, const StringTableReader &strtab)
Decode a serialized version of this object from data.
Definition: Symbol.cpp:599
lldb_private::Symbol::SetExternal
void SetExternal(bool b)
Definition: Symbol.h:182
lldb_private::Symbol::GetPrologueByteSize
uint32_t GetPrologueByteSize()
Definition: Symbol.cpp:259
lldb_private::Symbol::GetSyntheticSymbolPrefix
static llvm::StringRef GetSyntheticSymbolPrefix()
Definition: Symbol.h:244
lldb_private::Symbol::SetSizeIsSynthesized
void SetSizeIsSynthesized(bool b)
Definition: Symbol.h:174
lldb_private::Symbol::GetDescription
void GetDescription(Stream *s, lldb::DescriptionLevel level, Target *target) const
Definition: Symbol.cpp:177
lldb_private::Symbol
Definition: Symbol.h:20
lldb_private::Symbol::ValueIsAddress
bool ValueIsAddress() const
Definition: Symbol.cpp:117
lldb_private::Symbol::DumpSymbolContext
void DumpSymbolContext(Stream *s) override
Dump the object's symbol context to the stream s.
Definition: Symbol.cpp:399
lldb_private::Symbol::GetMangled
const Mangled & GetMangled() const
Definition: Symbol.h:136
lldb_private::ConstStringTable
Many cache files require string tables to store data efficiently.
Definition: DataFileCache.h:180
lldb_private::Symbol::SetIsSynthetic
void SetIsSynthetic(bool b)
Definition: Symbol.h:170
lldb_private::Symbol::m_size_is_valid
uint16_t m_size_is_valid
Definition: Symbol.h:316
lldb::LanguageType
LanguageType
Programming language type.
Definition: lldb-enumerations.h:436
lldb_private::Symbol::SetType
void SetType(lldb::SymbolType type)
Definition: Symbol.h:155
lldb_private::SectionList
Definition: Section.h:34
lldb_private::Symbol::CalculateSymbolContextModule
lldb::ModuleSP CalculateSymbolContextModule() override
Definition: Symbol.cpp:391
lldb::offset_t
uint64_t offset_t
Definition: lldb-types.h:87
lldb_private::Symbol::GetReExportedSymbolName
ConstString GetReExportedSymbolName() const
Definition: Symbol.cpp:125
lldb_private::Symbol::CalculateSymbolContextSymbol
Symbol * CalculateSymbolContextSymbol() override
Definition: Symbol.cpp:397
lldb_private::Symbol::m_uid
uint32_t m_uid
Definition: Symbol.h:300
lldb_private::Stream
Definition: Stream.h:28
lldb::addr_t
uint64_t addr_t
Definition: lldb-types.h:83
lldb_private::Symbol::IsSyntheticWithAutoGeneratedName
bool IsSyntheticWithAutoGeneratedName() const
Definition: Symbol.cpp:572
lldb_private::SymbolContext
Definition: SymbolContext.h:33
lldb_private::Target
Definition: Target.h:469
lldb_private::Symbol::m_mangled
Mangled m_mangled
Definition: Symbol.h:325
lldb_private::Symbol::ResolveCallableAddress
lldb::addr_t ResolveCallableAddress(Target &target) const
Definition: Symbol.cpp:506
lldb_private::Symbol::GetRawValue
uint64_t GetRawValue() const
Get the raw value of the symbol from the symbol table.
Definition: Symbol.h:94
lldb_private::Symbol::m_is_synthetic
uint16_t m_is_synthetic
Definition: Symbol.h:305
lldb_private::Symbol::GetFlags
uint32_t GetFlags() const
Definition: Symbol.h:159
lldb_private::Symbol::m_type_data_resolved
uint16_t m_type_data_resolved
Definition: Symbol.h:303
lldb_private::Symbol::ContainsFileAddress
bool ContainsFileAddress(lldb::addr_t file_addr) const
Definition: Symbol.cpp:568
lldb_private::Symbol::Dump
void Dump(Stream *s, Target *target, uint32_t index, Mangled::NamePreference name_preference=Mangled::ePreferDemangled) const
Definition: Symbol.cpp:212
lldb_private::FileSpec
Definition: FileSpec.h:55
lldb_private::Symbol::SetByteSize
void SetByteSize(lldb::addr_t size)
Definition: Symbol.h:196
lldb_private::Symbol::GetSizeIsSibling
bool GetSizeIsSibling() const
Definition: Symbol.h:201
lldb_private::DataExtractor
Definition: DataExtractor.h:48
lldb_private::ModuleList
Definition: ModuleList.h:82
lldb_private::Symbol::SetID
void SetID(uint32_t uid)
Definition: Symbol.h:129
lldb_private::Symbol::SetReExportedSymbolSharedLibrary
bool SetReExportedSymbolSharedLibrary(const FileSpec &fspec)
Definition: Symbol.cpp:158
lldb_private::Symbol::m_size_is_sibling
uint16_t m_size_is_sibling
Definition: Symbol.h:311
lldb_private::Symbol::m_demangled_is_synthesized
uint16_t m_demangled_is_synthesized
Definition: Symbol.h:317
lldb_private::Symbol::CalculateSymbolContext
void CalculateSymbolContext(SymbolContext *sc) override
Reconstruct the object's symbol context into sc.
Definition: Symbol.cpp:382
lldb_private::Address::GetFileAddress
lldb::addr_t GetFileAddress() const
Get the file address.
Definition: Address.cpp:291
lldb_private::Symbol::GetAddressRef
Address & GetAddressRef()
Definition: Symbol.h:57
lldb_private::Symbol::GetInstructions
lldb::DisassemblerSP GetInstructions(const ExecutionContext &exe_ctx, const char *flavor, bool prefer_file_cache)
Definition: Symbol.cpp:541
SymbolContextScope.h
lldb_private::Symbol::operator=
const Symbol & operator=(const Symbol &rhs)
Definition: Symbol.cpp:75
lldb_private::ConstString
Definition: ConstString.h:39
lldb_private::Symbol::GetAddressRef
const Address & GetAddressRef() const
Definition: Symbol.h:59
lldb_private::Symbol::Clear
void Clear()
Definition: Symbol.cpp:98
lldb_private::Symbol::m_contains_linker_annotations
uint16_t m_contains_linker_annotations
Definition: Symbol.h:320
lldb_private::AddressRange
Definition: AddressRange.h:25
lldb_private::Symbol::IsExternal
bool IsExternal() const
Definition: Symbol.h:180
lldb_private::Symbol::Compare
bool Compare(ConstString name, lldb::SymbolType type) const
Definition: Symbol.cpp:332
lldb_private::Symbol::IsSynthetic
bool IsSynthetic() const
Definition: Symbol.h:166
lldb_private::Symbol::ContainsLinkerAnnotations
bool ContainsLinkerAnnotations() const
Definition: Symbol.h:215
lldb_private::Symbol::GetSizeIsSynthesized
bool GetSizeIsSynthesized() const
Definition: Symbol.h:172
lldb_private::Symbol::GetMangled
Mangled & GetMangled()
Definition: Symbol.h:131
lldb_private::Symbol::GetTypeAsString
const char * GetTypeAsString() const
Definition: Symbol.cpp:345
lldb::SymbolType
SymbolType
Symbol types.
Definition: lldb-enumerations.h:618
lldb_private::Symbol::GetIntegerValue
uint64_t GetIntegerValue(uint64_t fail_value=0) const
Definition: Symbol.h:102
UserID.h
lldb_private::Symbol::m_is_external
uint16_t m_is_external
Definition: Symbol.h:310
lldb_private::SymbolContextScope
Definition: SymbolContextScope.h:64
lldb-private.h
lldb_private::Symbol::GetName
ConstString GetName() const
Definition: Symbol.cpp:500
lldb_private::Symbol::m_flags
uint32_t m_flags
Definition: Symbol.h:329
lldb_private::Symbol::SetFlags
void SetFlags(uint32_t flags)
Definition: Symbol.h:161
lldb_private::Symbol::Symbol
Symbol()
Definition: Symbol.cpp:26
lldb_private::Symbol::GetByteSizeIsValid
bool GetByteSizeIsValid() const
Definition: Symbol.h:192
lldb_private::Symbol::IsDebug
bool IsDebug() const
Definition: Symbol.h:176
lldb_private::ModuleSpec
Definition: ModuleSpec.h:27
lldb_private::Symbol::GetDemangledNameIsSynthesized
bool GetDemangledNameIsSynthesized() const
Definition: Symbol.h:209
lldb_private::Symbol::GetDisassembly
bool GetDisassembly(const ExecutionContext &exe_ctx, const char *flavor, bool prefer_file_cache, Stream &strm)
Definition: Symbol.cpp:553
lldb_private::Symbol::GetReExportedSymbolSharedLibrary
FileSpec GetReExportedSymbolSharedLibrary() const
Definition: Symbol.cpp:139
uint32_t
lldb_private::Address
Definition: Address.h:59
lldb_private::Symbol::GetLanguage
lldb::LanguageType GetLanguage() const
Definition: Symbol.h:123
lldb_private::Symbol::GetByteSize
lldb::addr_t GetByteSize() const
Definition: Symbol.cpp:414
UINT32_MAX
#define UINT32_MAX
Definition: lldb-defines.h:19
lldb_private::Symbol::SetContainsLinkerAnnotations
void SetContainsLinkerAnnotations(bool b)
Definition: Symbol.h:218
uint16_t
lldb_private::Symbol::SynthesizeNameIfNeeded
void SynthesizeNameIfNeeded() const
Definition: Symbol.cpp:581
lldb_private::Symbol::GetFileAddress
lldb::addr_t GetFileAddress() const
Definition: Symbol.cpp:486
lldb_private::AddressRange::SetByteSize
void SetByteSize(lldb::addr_t byte_size)
Set accessor for the byte size of this range.
Definition: AddressRange.h:237
lldb_private::Symbol::IsWeak
bool IsWeak() const
Definition: Symbol.h:188
lldb_private::Symbol::m_addr_range
AddressRange m_addr_range
Definition: Symbol.h:326
lldb_private
A class that represents a running process on the host machine.
Definition: SBCommandInterpreterRunOptions.h:16
lldb_private::Symbol::operator==
bool operator==(const Symbol &rhs) const
Definition: Symbol.cpp:689
lldb_private::Symbol::SetSizeIsSibling
void SetSizeIsSibling(bool b)
Definition: Symbol.h:203
lldb_private::Symbol::IsTrampoline
bool IsTrampoline() const
Definition: Symbol.cpp:173
lldb_private::Address::GetOffset
lldb::addr_t GetOffset() const
Get the section relative offset value.
Definition: Address.h:319
lldb_private::Symbol::m_type_data
uint16_t m_type_data
Definition: Symbol.h:302
lldb_private::Symbol::GetNameNoArguments
ConstString GetNameNoArguments() const
Definition: Symbol.cpp:502
lldb_private::Symbol::IsIndirect
bool IsIndirect() const
Definition: Symbol.cpp:175
lldb_private::Symbol::SetReExportedSymbolName
void SetReExportedSymbolName(ConstString name)
Definition: Symbol.cpp:151
lldb_private::Symbol::GetLoadAddress
lldb::addr_t GetLoadAddress(Target *target) const
Definition: Symbol.cpp:493
lldb_private::Symbol::GetDisplayName
ConstString GetDisplayName() const
Definition: Symbol.cpp:121
AddressRange.h
lldb_private::Symbol::GetType
lldb::SymbolType GetType() const
Definition: Symbol.h:153
lldb_private::Symbol::m_size_is_synthesized
uint16_t m_size_is_synthesized
Definition: Symbol.h:313
lldb_private::Symbol::m_is_weak
uint16_t m_is_weak
Definition: Symbol.h:323
lldb_private::Symbol::ResolveReExportedSymbol
Symbol * ResolveReExportedSymbol(Target &target) const
Definition: Symbol.cpp:472
lldb_private::Symbol::SetDemangledNameIsSynthesized
void SetDemangledNameIsSynthesized(bool b)
Definition: Symbol.h:213
lldb_private::Symbol::ResolveReExportedSymbolInModuleSpec
Symbol * ResolveReExportedSymbolInModuleSpec(Target &target, ConstString &reexport_name, lldb_private::ModuleSpec &module_spec, lldb_private::ModuleList &seen_modules) const
Definition: Symbol.cpp:416
lldb::DescriptionLevel
DescriptionLevel
Description levels for "void GetDescription(Stream *, DescriptionLevel)" calls.
Definition: lldb-enumerations.h:207
lldb_private::Symbol::m_is_debug
uint16_t m_is_debug
Definition: Symbol.h:308
lldb_private::Symbol::GetSiblingIndex
uint32_t GetSiblingIndex() const
Definition: Symbol.cpp:169
lldb_private::Symbol::GetID
uint32_t GetID() const
Definition: Symbol.h:121
lldb_private::Symbol::SetIsWeak
void SetIsWeak(bool b)
Definition: Symbol.h:190
lldb_private::Symbol::GetAddress
Address GetAddress() const
Definition: Symbol.h:73