Type.h revision 52f792329be5db8e38961350589e97e8f2823acd 
1//===-- Type.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_Type_h_
11#define liblldb_Type_h_
12
13#include "lldb/lldb-private.h"
14#include "lldb/Core/ClangForward.h"
15#include "lldb/Core/ConstString.h"
16#include "lldb/Core/UserID.h"
17#include "lldb/Symbol/ClangASTType.h"
18#include "lldb/Symbol/Declaration.h"
19
20#include <set>
21
22namespace lldb_private {
23
24class SymbolFileType :
25    public std::enable_shared_from_this<SymbolFileType>,
26    public UserID
27    {
28    public:
29        SymbolFileType (SymbolFile &symbol_file, lldb::user_id_t uid) :
30            UserID (uid),
31            m_symbol_file (symbol_file)
32        {
33        }
34
35        ~SymbolFileType ()
36        {
37        }
38
39        Type *
40        operator->()
41        {
42            return GetType ();
43        }
44
45        Type *
46        GetType ();
47
48    protected:
49        SymbolFile &m_symbol_file;
50        lldb::TypeSP m_type_sp;
51    };
52
53class Type :
54    public std::enable_shared_from_this<Type>,
55    public UserID
56{
57public:
58    typedef enum EncodingDataTypeTag
59    {
60        eEncodingInvalid,
61        eEncodingIsUID,                 ///< This type is the type whose UID is m_encoding_uid
62        eEncodingIsConstUID,            ///< This type is the type whose UID is m_encoding_uid with the const qualifier added
63        eEncodingIsRestrictUID,         ///< This type is the type whose UID is m_encoding_uid with the restrict qualifier added
64        eEncodingIsVolatileUID,         ///< This type is the type whose UID is m_encoding_uid with the volatile qualifier added
65        eEncodingIsTypedefUID,          ///< This type is pointer to a type whose UID is m_encoding_uid
66        eEncodingIsPointerUID,          ///< This type is pointer to a type whose UID is m_encoding_uid
67        eEncodingIsLValueReferenceUID,  ///< This type is L value reference to a type whose UID is m_encoding_uid
68        eEncodingIsRValueReferenceUID,  ///< This type is R value reference to a type whose UID is m_encoding_uid
69        eEncodingIsSyntheticUID
70    } EncodingDataType;
71
72    typedef enum ResolveStateTag
73    {
74        eResolveStateUnresolved = 0,
75        eResolveStateForward    = 1,
76        eResolveStateLayout     = 2,
77        eResolveStateFull       = 3
78    } ResolveState;
79
80    Type (lldb::user_id_t uid,
81          SymbolFile* symbol_file,
82          const ConstString &name,
83          uint64_t byte_size,
84          SymbolContextScope *context,
85          lldb::user_id_t encoding_uid,
86          EncodingDataType encoding_uid_type,
87          const Declaration& decl,
88          const ClangASTType &clang_qual_type,
89          ResolveState clang_type_resolve_state);
90
91    // This makes an invalid type.  Used for functions that return a Type when they
92    // get an error.
93    Type();
94
95    Type (const Type &rhs);
96
97    const Type&
98    operator= (const Type& rhs);
99
100    void
101    Dump(Stream *s, bool show_context);
102
103    void
104    DumpTypeName(Stream *s);
105
106
107    void
108    GetDescription (Stream *s, lldb::DescriptionLevel level, bool show_name);
109
110    SymbolFile *
111    GetSymbolFile()
112    {
113        return m_symbol_file;
114    }
115    const SymbolFile *
116    GetSymbolFile() const
117    {
118        return m_symbol_file;
119    }
120
121    TypeList*
122    GetTypeList();
123
124    const ConstString&
125    GetName();
126
127    uint64_t
128    GetByteSize();
129
130    uint32_t
131    GetNumChildren (bool omit_empty_base_classes);
132
133    bool
134    IsAggregateType ();
135
136    bool
137    IsValidType ()
138    {
139        return m_encoding_uid_type != eEncodingInvalid;
140    }
141
142    bool
143    IsTypedef ()
144    {
145        return m_encoding_uid_type == eEncodingIsTypedefUID;
146    }
147
148    lldb::TypeSP
149    GetTypedefType();
150
151    const ConstString &
152    GetName () const
153    {
154        return m_name;
155    }
156
157    ConstString
158    GetQualifiedName ();
159
160    void
161    DumpValue(ExecutionContext *exe_ctx,
162              Stream *s,
163              const DataExtractor &data,
164              uint32_t data_offset,
165              bool show_type,
166              bool show_summary,
167              bool verbose,
168              lldb::Format format = lldb::eFormatDefault);
169
170    bool
171    DumpValueInMemory(ExecutionContext *exe_ctx,
172                      Stream *s,
173                      lldb::addr_t address,
174                      AddressType address_type,
175                      bool show_types,
176                      bool show_summary,
177                      bool verbose);
178
179    bool
180    ReadFromMemory (ExecutionContext *exe_ctx,
181                    lldb::addr_t address,
182                    AddressType address_type,
183                    DataExtractor &data);
184
185    bool
186    WriteToMemory (ExecutionContext *exe_ctx,
187                   lldb::addr_t address,
188                   AddressType address_type,
189                   DataExtractor &data);
190
191    bool
192    GetIsDeclaration() const;
193
194    void
195    SetIsDeclaration(bool b);
196
197    bool
198    GetIsExternal() const;
199
200    void
201    SetIsExternal(bool b);
202
203    lldb::Format
204    GetFormat ();
205
206    lldb::Encoding
207    GetEncoding (uint64_t &count);
208
209    SymbolContextScope *
210    GetSymbolContextScope()
211    {
212        return m_context;
213    }
214    const SymbolContextScope *
215    GetSymbolContextScope() const
216    {
217        return m_context;
218    }
219    void
220    SetSymbolContextScope(SymbolContextScope *context)
221    {
222        m_context = context;
223    }
224
225    const lldb_private::Declaration &
226    GetDeclaration () const;
227
228    // Get the clang type, and resolve definitions for any
229    // class/struct/union/enum types completely.
230    ClangASTType
231    GetClangFullType ();
232
233    // Get the clang type, and resolve definitions enough so that the type could
234    // have layout performed. This allows ptrs and refs to class/struct/union/enum
235    // types remain forward declarations.
236    ClangASTType
237    GetClangLayoutType ();
238
239    // Get the clang type and leave class/struct/union/enum types as forward
240    // declarations if they haven't already been fully defined.
241    ClangASTType
242    GetClangForwardType ();
243
244    ClangASTContext &
245    GetClangASTContext ();
246
247    static int
248    Compare(const Type &a, const Type &b);
249
250    // From a fully qualified typename, split the type into the type basename
251    // and the remaining type scope (namespaces/classes).
252    static bool
253    GetTypeScopeAndBasename (const char* &name_cstr,
254                             std::string &scope,
255                             std::string &basename,
256                             lldb::TypeClass &type_class);
257    void
258    SetEncodingType (Type *encoding_type)
259    {
260        m_encoding_type = encoding_type;
261    }
262
263    uint32_t
264    GetEncodingMask ();
265
266    ClangASTType
267    CreateClangTypedefType (Type *typedef_type, Type *base_type);
268
269    bool
270    IsRealObjCClass();
271
272    bool
273    IsCompleteObjCClass()
274    {
275        return m_flags.is_complete_objc_class;
276    }
277
278    void
279    SetIsCompleteObjCClass(bool is_complete_objc_class)
280    {
281        m_flags.is_complete_objc_class = is_complete_objc_class;
282    }
283
284protected:
285    ConstString m_name;
286    SymbolFile *m_symbol_file;
287    SymbolContextScope *m_context; // The symbol context in which this type is defined
288    Type *m_encoding_type;
289    lldb::user_id_t m_encoding_uid;
290    EncodingDataType m_encoding_uid_type;
291    uint64_t m_byte_size;
292    Declaration m_decl;
293    ClangASTType m_clang_type;
294
295    struct Flags {
296        ResolveState    clang_type_resolve_state : 2;
297        bool            is_complete_objc_class   : 1;
298    } m_flags;
299
300    Type *
301    GetEncodingType ();
302
303    bool
304    ResolveClangType (ResolveState clang_type_resolve_state);
305};
306
307
308///
309/// Sometimes you can find the name of the type corresponding to an object, but we don't have debug
310/// information for it.  If that is the case, you can return one of these objects, and then if it
311/// has a full type, you can use that, but if not at least you can print the name for informational
312/// purposes.
313///
314
315class TypeAndOrName
316{
317public:
318    TypeAndOrName ();
319    TypeAndOrName (lldb::TypeSP &type_sp);
320    TypeAndOrName (const char *type_str);
321    TypeAndOrName (const TypeAndOrName &rhs);
322    TypeAndOrName (ConstString &type_const_string);
323
324    TypeAndOrName &
325    operator= (const TypeAndOrName &rhs);
326
327    bool
328    operator==(const TypeAndOrName &other) const;
329
330    bool
331    operator!=(const TypeAndOrName &other) const;
332
333    ConstString GetName () const;
334
335    lldb::TypeSP
336    GetTypeSP () const
337    {
338        return m_type_sp;
339    }
340
341    void
342    SetName (const ConstString &type_name);
343
344    void
345    SetName (const char *type_name_cstr);
346
347    void
348    SetTypeSP (lldb::TypeSP type_sp);
349
350    bool
351    IsEmpty ();
352
353    bool
354    HasName ();
355
356    bool
357    HasTypeSP ();
358
359    void
360    Clear ();
361
362    operator
363    bool ()
364    {
365        return !IsEmpty();
366    }
367
368private:
369    lldb::TypeSP m_type_sp;
370    ConstString m_type_name;
371};
372
373// the two classes here are used by the public API as a backend to
374// the SBType and SBTypeList classes
375
376class TypeImpl
377{
378public:
379
380    TypeImpl() :
381        m_clang_ast_type(),
382        m_type_sp()
383    {
384    }
385
386    TypeImpl(const TypeImpl& rhs) :
387        m_clang_ast_type(rhs.m_clang_ast_type),
388        m_type_sp(rhs.m_type_sp)
389    {
390    }
391
392    TypeImpl(const lldb_private::ClangASTType& type);
393
394    TypeImpl(const lldb::TypeSP& type);
395
396    TypeImpl&
397    operator = (const TypeImpl& rhs);
398
399    bool
400    operator == (const TypeImpl& rhs)
401    {
402        return m_clang_ast_type == rhs.m_clang_ast_type && m_type_sp.get() == rhs.m_type_sp.get();
403    }
404
405    bool
406    operator != (const TypeImpl& rhs)
407    {
408        return m_clang_ast_type != rhs.m_clang_ast_type || m_type_sp.get() != rhs.m_type_sp.get();
409    }
410
411    bool
412    IsValid()
413    {
414        return m_type_sp.get() != NULL || m_clang_ast_type.IsValid();
415    }
416
417    const lldb_private::ClangASTType &
418    GetClangASTType() const
419    {
420        return m_clang_ast_type;
421    }
422
423    clang::ASTContext*
424    GetASTContext();
425
426    lldb::clang_type_t
427    GetOpaqueQualType();
428
429    lldb::TypeSP
430    GetTypeSP ()
431    {
432        return m_type_sp;
433    }
434
435    ConstString
436    GetName ();
437
438    bool
439    GetDescription (lldb_private::Stream &strm,
440                    lldb::DescriptionLevel description_level);
441
442    void
443    SetType (const lldb::TypeSP &type_sp);
444
445private:
446    ClangASTType m_clang_ast_type;
447    lldb::TypeSP m_type_sp;
448};
449
450class TypeListImpl
451{
452public:
453    TypeListImpl() :
454        m_content()
455    {
456    }
457
458    void
459    Append (const lldb::TypeImplSP& type)
460    {
461        m_content.push_back(type);
462    }
463
464    class AppendVisitor
465    {
466    public:
467        AppendVisitor(TypeListImpl &type_list) :
468            m_type_list(type_list)
469        {
470        }
471
472        void
473        operator() (const lldb::TypeImplSP& type)
474        {
475            m_type_list.Append(type);
476        }
477
478    private:
479        TypeListImpl &m_type_list;
480    };
481
482    void
483    Append (const lldb_private::TypeList &type_list);
484
485    lldb::TypeImplSP
486    GetTypeAtIndex(size_t idx)
487    {
488        lldb::TypeImplSP type_sp;
489        if (idx < GetSize())
490            type_sp = m_content[idx];
491        return type_sp;
492    }
493
494    size_t
495    GetSize()
496    {
497        return m_content.size();
498    }
499
500private:
501    std::vector<lldb::TypeImplSP> m_content;
502};
503
504class TypeMemberImpl
505{
506public:
507    TypeMemberImpl () :
508        m_type_impl_sp (),
509        m_bit_offset (0),
510        m_name (),
511        m_bitfield_bit_size (0),
512        m_is_bitfield (false)
513
514    {
515    }
516
517    TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
518                    uint64_t bit_offset,
519                    const ConstString &name,
520                    uint32_t bitfield_bit_size = 0,
521                    bool is_bitfield = false) :
522        m_type_impl_sp (type_impl_sp),
523        m_bit_offset (bit_offset),
524        m_name (name),
525        m_bitfield_bit_size (bitfield_bit_size),
526        m_is_bitfield (is_bitfield)
527    {
528    }
529
530    TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
531                    uint64_t bit_offset):
532        m_type_impl_sp (type_impl_sp),
533        m_bit_offset (bit_offset),
534        m_name (),
535        m_bitfield_bit_size (0),
536        m_is_bitfield (false)
537    {
538        if (m_type_impl_sp)
539            m_name = m_type_impl_sp->GetName();
540    }
541
542    const lldb::TypeImplSP &
543    GetTypeImpl ()
544    {
545        return m_type_impl_sp;
546    }
547
548    const ConstString &
549    GetName () const
550    {
551        return m_name;
552    }
553
554    uint64_t
555    GetBitOffset () const
556    {
557        return m_bit_offset;
558    }
559
560    uint32_t
561    GetBitfieldBitSize () const
562    {
563        return m_bitfield_bit_size;
564    }
565
566    void
567    SetBitfieldBitSize (uint32_t bitfield_bit_size)
568    {
569        m_bitfield_bit_size = bitfield_bit_size;
570    }
571
572    bool
573    GetIsBitfield () const
574    {
575        return m_is_bitfield;
576    }
577
578    void
579    SetIsBitfield (bool is_bitfield)
580    {
581        m_is_bitfield = is_bitfield;
582    }
583
584protected:
585    lldb::TypeImplSP m_type_impl_sp;
586    uint64_t m_bit_offset;
587    ConstString m_name;
588    uint32_t m_bitfield_bit_size; // Bit size for bitfield members only
589    bool m_is_bitfield;
590};
591
592
593} // namespace lldb_private
594
595#endif  // liblldb_Type_h_
596
597