1 //===-- Symbol.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 liblldb_Symbol_h_
11 #define liblldb_Symbol_h_
12 
13 #include "lldb/lldb-private.h"
14 #include "lldb/Core/AddressRange.h"
15 #include "lldb/Core/Mangled.h"
16 #include "lldb/Core/UserID.h"
17 #include "lldb/Symbol/SymbolContextScope.h"
18 
19 namespace lldb_private {
20 
21 class Symbol :
22     public SymbolContextScope
23 {
24 public:
25     // ObjectFile readers can classify their symbol table entries and searches can be made
26     // on specific types where the symbol values will have drastically different meanings
27     // and sorting requirements.
28     Symbol();
29 
30     Symbol (uint32_t symID,
31             const char *name,
32             bool name_is_mangled,
33             lldb::SymbolType type,
34             bool external,
35             bool is_debug,
36             bool is_trampoline,
37             bool is_artificial,
38             const lldb::SectionSP &section_sp,
39             lldb::addr_t value,
40             lldb::addr_t size,
41             bool size_is_valid,
42             uint32_t flags);
43 
44     Symbol (uint32_t symID,
45             const char *name,
46             bool name_is_mangled,
47             lldb::SymbolType type,
48             bool external,
49             bool is_debug,
50             bool is_trampoline,
51             bool is_artificial,
52             const AddressRange &range,
53             bool size_is_valid,
54             uint32_t flags);
55 
56     Symbol (const Symbol& rhs);
57 
58     const Symbol&
59     operator= (const Symbol& rhs);
60 
61     void
62     Clear();
63 
64     bool
65     Compare (const ConstString& name, lldb::SymbolType type) const;
66 
67     void
68     Dump (Stream *s, Target *target, uint32_t index) const;
69 
70     bool
71     ValueIsAddress() const;
72 
73     //------------------------------------------------------------------
74     // Access the address value. Do NOT hand out the AddressRange as an
75     // object as the byte size of the address range may not be filled in
76     // and it should be accessed via GetByteSize().
77     //------------------------------------------------------------------
78     Address &
GetAddress()79     GetAddress()
80     {
81         return m_addr_range.GetBaseAddress();
82     }
83 
84     //------------------------------------------------------------------
85     // Access the address value. Do NOT hand out the AddressRange as an
86     // object as the byte size of the address range may not be filled in
87     // and it should be accessed via GetByteSize().
88     //------------------------------------------------------------------
89     const Address &
GetAddress()90     GetAddress() const
91     {
92         return m_addr_range.GetBaseAddress();
93     }
94 
95     const ConstString &
GetName()96     GetName () const
97     {
98         return m_mangled.GetName();
99     }
100 
101     uint32_t
GetID()102     GetID() const
103     {
104         return m_uid;
105     }
106 
107     void
SetID(uint32_t uid)108     SetID(uint32_t uid)
109     {
110         m_uid = uid;
111     }
112 
113     Mangled&
GetMangled()114     GetMangled ()
115     {
116         return m_mangled;
117     }
118 
119     const Mangled&
GetMangled()120     GetMangled () const
121     {
122         return m_mangled;
123     }
124 
125     uint32_t
126     GetSiblingIndex () const;
127 
128     lldb::SymbolType
GetType()129     GetType () const
130     {
131         return (lldb::SymbolType)m_type;
132     }
133 
134     void
SetType(lldb::SymbolType type)135     SetType (lldb::SymbolType type)
136     {
137         m_type = (lldb::SymbolType)type;
138     }
139 
140     const char *
141     GetTypeAsString () const;
142 
143     uint32_t
GetFlags()144     GetFlags () const
145     {
146         return m_flags;
147     }
148 
149     void
SetFlags(uint32_t flags)150     SetFlags (uint32_t flags)
151     {
152         m_flags = flags;
153     }
154 
155     void
156     GetDescription (Stream *s, lldb::DescriptionLevel level, Target *target) const;
157 
158     bool
IsSynthetic()159     IsSynthetic () const
160     {
161         return m_is_synthetic;
162     }
163 
164     void
SetIsSynthetic(bool b)165     SetIsSynthetic (bool b)
166     {
167         m_is_synthetic = b;
168     }
169 
170 
171     bool
GetSizeIsSynthesized()172     GetSizeIsSynthesized() const
173     {
174         return m_size_is_synthesized;
175     }
176 
177     void
SetSizeIsSynthesized(bool b)178     SetSizeIsSynthesized(bool b)
179     {
180         m_size_is_synthesized = b;
181     }
182 
183     bool
IsDebug()184     IsDebug () const
185     {
186         return m_is_debug;
187     }
188 
189     void
SetDebug(bool b)190     SetDebug (bool b)
191     {
192         m_is_debug = b;
193     }
194 
195     bool
IsExternal()196     IsExternal () const
197     {
198         return m_is_external;
199     }
200 
201     void
SetExternal(bool b)202     SetExternal (bool b)
203     {
204         m_is_external = b;
205     }
206 
207     bool
208     IsTrampoline () const;
209 
210     bool
211     IsIndirect () const;
212 
213     bool
GetByteSizeIsValid()214     GetByteSizeIsValid () const
215     {
216         return m_size_is_valid;
217     }
218 
219     lldb::addr_t
220     GetByteSize () const;
221 
222     void
SetByteSize(lldb::addr_t size)223     SetByteSize (lldb::addr_t size)
224     {
225         m_size_is_valid = size > 0;
226         m_addr_range.SetByteSize(size);
227     }
228 
229     bool
GetSizeIsSibling()230     GetSizeIsSibling () const
231     {
232         return m_size_is_sibling;
233     }
234 
235     void
SetSizeIsSibling(bool b)236     SetSizeIsSibling (bool b)
237     {
238         m_size_is_sibling = b;
239     }
240 
241 //    void
242 //    SetValue (Address &value)
243 //    {
244 //        m_addr_range.GetBaseAddress() = value;
245 //    }
246 //
247 //    void
248 //    SetValue (const AddressRange &range)
249 //    {
250 //        m_addr_range = range;
251 //    }
252 //
253 //    void
254 //    SetValue (lldb::addr_t value);
255 //    {
256 //        m_addr_range.GetBaseAddress().SetRawAddress(value);
257 //    }
258 
259     // If m_type is "Code" or "Function" then this will return the prologue size
260     // in bytes, else it will return zero.
261     uint32_t
262     GetPrologueByteSize ();
263 
264     bool
GetDemangledNameIsSynthesized()265     GetDemangledNameIsSynthesized() const
266     {
267         return m_demangled_is_synthesized;
268     }
269     void
SetDemangledNameIsSynthesized(bool b)270     SetDemangledNameIsSynthesized(bool b)
271     {
272         m_demangled_is_synthesized = b;
273     }
274 
275     //------------------------------------------------------------------
276     /// @copydoc SymbolContextScope::CalculateSymbolContext(SymbolContext*)
277     ///
278     /// @see SymbolContextScope
279     //------------------------------------------------------------------
280     virtual void
281     CalculateSymbolContext (SymbolContext *sc);
282 
283     virtual lldb::ModuleSP
284     CalculateSymbolContextModule ();
285 
286     virtual Symbol *
287     CalculateSymbolContextSymbol ();
288 
289     //------------------------------------------------------------------
290     /// @copydoc SymbolContextScope::DumpSymbolContext(Stream*)
291     ///
292     /// @see SymbolContextScope
293     //------------------------------------------------------------------
294     virtual void
295     DumpSymbolContext (Stream *s);
296 
297 protected:
298 
299     uint32_t        m_uid;                  // User ID (usually the original symbol table index)
300     uint16_t        m_type_data;            // data specific to m_type
301     uint16_t        m_type_data_resolved:1, // True if the data in m_type_data has already been calculated
302                     m_is_synthetic:1,       // non-zero if this symbol is not actually in the symbol table, but synthesized from other info in the object file.
303                     m_is_debug:1,           // non-zero if this symbol is debug information in a symbol
304                     m_is_external:1,        // non-zero if this symbol is globally visible
305                     m_size_is_sibling:1,    // m_size contains the index of this symbol's sibling
306                     m_size_is_synthesized:1,// non-zero if this symbol's size was calculated using a delta between this symbol and the next
307                     m_size_is_valid:1,
308                     m_demangled_is_synthesized:1, // The demangled name was created should not be used for expressions or other lookups
309                     m_type:8;
310     Mangled         m_mangled;              // uniqued symbol name/mangled name pair
311     AddressRange    m_addr_range;           // Contains the value, or the section offset address when the value is an address in a section, and the size (if any)
312     uint32_t        m_flags;                // A copy of the flags from the original symbol table, the ObjectFile plug-in can interpret these
313 };
314 
315 } // namespace lldb_private
316 
317 #endif  // liblldb_Symbol_h_
318