Type.h revision 262528 
11590Srgrimes//===-- Type.h --------------------------------------------------*- C++ -*-===//
250477Speter//
31590Srgrimes//                     The LLVM Compiler Infrastructure
41590Srgrimes//
535745Sbde// This file is distributed under the University of Illinois Open Source
6146261Sru// License. See LICENSE.TXT for details.
72474Sache//
8249657Sed//===----------------------------------------------------------------------===//
9249657Sed
101590Srgrimes#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// these classes are used to back the SBType* objects
308
309class TypePair {
310private:
311    ClangASTType clang_type;
312    lldb::TypeSP type_sp;
313
314public:
315    TypePair () : clang_type(), type_sp() {}
316    TypePair (ClangASTType type) :
317    clang_type(type),
318    type_sp()
319    {
320    }
321
322    TypePair (lldb::TypeSP type) :
323    clang_type(),
324    type_sp(type)
325    {
326        clang_type = type_sp->GetClangForwardType();
327    }
328
329    bool
330    IsValid () const
331    {
332        return clang_type.IsValid() || (type_sp.get() != nullptr);
333    }
334
335    explicit operator bool () const
336    {
337        return IsValid();
338    }
339
340    bool
341    operator == (const TypePair& rhs) const
342    {
343        return clang_type == rhs.clang_type &&
344        type_sp.get() == rhs.type_sp.get();
345    }
346
347    bool
348    operator != (const TypePair& rhs) const
349    {
350        return clang_type != rhs.clang_type ||
351        type_sp.get() != rhs.type_sp.get();
352    }
353
354    void
355    Clear ()
356    {
357        clang_type.Clear();
358        type_sp.reset();
359    }
360
361    ConstString
362    GetName () const
363    {
364        if (type_sp)
365            return type_sp->GetName();
366        if (clang_type)
367            return clang_type.GetTypeName();
368        return ConstString ();
369    }
370
371    void
372    SetType (ClangASTType type)
373    {
374        type_sp.reset();
375        clang_type = type;
376    }
377
378    void
379    SetType (lldb::TypeSP type)
380    {
381        type_sp = type;
382        clang_type = type_sp->GetClangForwardType();
383    }
384
385    lldb::TypeSP
386    GetTypeSP () const
387    {
388        return type_sp;
389    }
390
391    ClangASTType
392    GetClangASTType () const
393    {
394        return clang_type;
395    }
396
397    ClangASTType
398    GetPointerType () const
399    {
400        if (type_sp)
401            return type_sp->GetClangLayoutType().GetPointerType();
402        return clang_type.GetPointerType();
403    }
404
405    ClangASTType
406    GetPointeeType () const
407    {
408        if (type_sp)
409            return type_sp->GetClangFullType().GetPointeeType();
410        return clang_type.GetPointeeType();
411    }
412
413    ClangASTType
414    GetReferenceType () const
415    {
416        if (type_sp)
417            return type_sp->GetClangLayoutType().GetLValueReferenceType();
418        return clang_type.GetLValueReferenceType();
419    }
420
421    ClangASTType
422    GetTypedefedType () const
423    {
424        if (type_sp)
425            return type_sp->GetClangFullType().GetTypedefedType();
426        return clang_type.GetTypedefedType();
427    }
428
429    ClangASTType
430    GetDereferencedType () const
431    {
432        if (type_sp)
433            return type_sp->GetClangFullType().GetNonReferenceType();
434        return clang_type.GetNonReferenceType();
435    }
436
437    ClangASTType
438    GetUnqualifiedType () const
439    {
440        if (type_sp)
441            return type_sp->GetClangLayoutType().GetFullyUnqualifiedType();
442        return clang_type.GetFullyUnqualifiedType();
443    }
444
445    ClangASTType
446    GetCanonicalType () const
447    {
448        if (type_sp)
449            return type_sp->GetClangFullType().GetCanonicalType();
450        return clang_type.GetCanonicalType();
451    }
452
453    clang::ASTContext *
454    GetClangASTContext () const
455    {
456        return clang_type.GetASTContext();
457    }
458};
459
460class TypeImpl
461{
462public:
463
464    TypeImpl();
465
466    ~TypeImpl () {}
467
468    TypeImpl(const TypeImpl& rhs);
469
470    TypeImpl (lldb::TypeSP type_sp);
471
472    TypeImpl (ClangASTType clang_type);
473
474    TypeImpl (lldb::TypeSP type_sp, ClangASTType dynamic);
475
476    TypeImpl (ClangASTType clang_type, ClangASTType dynamic);
477
478    TypeImpl (TypePair pair, ClangASTType dynamic);
479
480    void
481    SetType (lldb::TypeSP type_sp);
482
483    void
484    SetType (ClangASTType clang_type);
485
486    void
487    SetType (lldb::TypeSP type_sp, ClangASTType dynamic);
488
489    void
490    SetType (ClangASTType clang_type, ClangASTType dynamic);
491
492    void
493    SetType (TypePair pair, ClangASTType dynamic);
494
495    TypeImpl&
496    operator = (const TypeImpl& rhs);
497
498    bool
499    operator == (const TypeImpl& rhs) const;
500
501    bool
502    operator != (const TypeImpl& rhs) const;
503
504    bool
505    IsValid() const;
506
507    explicit operator bool () const;
508
509    void Clear();
510
511    ConstString
512    GetName ()  const;
513
514    TypeImpl
515    GetPointerType () const;
516
517    TypeImpl
518    GetPointeeType () const;
519
520    TypeImpl
521    GetReferenceType () const;
522
523    TypeImpl
524    GetTypedefedType () const;
525
526    TypeImpl
527    GetDereferencedType () const;
528
529    TypeImpl
530    GetUnqualifiedType() const;
531
532    TypeImpl
533    GetCanonicalType() const;
534
535    ClangASTType
536    GetClangASTType (bool prefer_dynamic);
537
538    clang::ASTContext *
539    GetClangASTContext (bool prefer_dynamic);
540
541    bool
542    GetDescription (lldb_private::Stream &strm,
543                    lldb::DescriptionLevel description_level);
544
545private:
546    TypePair m_static_type;
547    ClangASTType m_dynamic_type;
548};
549
550class TypeListImpl
551{
552public:
553    TypeListImpl() :
554        m_content()
555    {
556    }
557
558    void
559    Append (const lldb::TypeImplSP& type)
560    {
561        m_content.push_back(type);
562    }
563
564    class AppendVisitor
565    {
566    public:
567        AppendVisitor(TypeListImpl &type_list) :
568            m_type_list(type_list)
569        {
570        }
571
572        void
573        operator() (const lldb::TypeImplSP& type)
574        {
575            m_type_list.Append(type);
576        }
577
578    private:
579        TypeListImpl &m_type_list;
580    };
581
582    void
583    Append (const lldb_private::TypeList &type_list);
584
585    lldb::TypeImplSP
586    GetTypeAtIndex(size_t idx)
587    {
588        lldb::TypeImplSP type_sp;
589        if (idx < GetSize())
590            type_sp = m_content[idx];
591        return type_sp;
592    }
593
594    size_t
595    GetSize()
596    {
597        return m_content.size();
598    }
599
600private:
601    std::vector<lldb::TypeImplSP> m_content;
602};
603
604class TypeMemberImpl
605{
606public:
607    TypeMemberImpl () :
608        m_type_impl_sp (),
609        m_bit_offset (0),
610        m_name (),
611        m_bitfield_bit_size (0),
612        m_is_bitfield (false)
613
614    {
615    }
616
617    TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
618                    uint64_t bit_offset,
619                    const ConstString &name,
620                    uint32_t bitfield_bit_size = 0,
621                    bool is_bitfield = false) :
622        m_type_impl_sp (type_impl_sp),
623        m_bit_offset (bit_offset),
624        m_name (name),
625        m_bitfield_bit_size (bitfield_bit_size),
626        m_is_bitfield (is_bitfield)
627    {
628    }
629
630    TypeMemberImpl (const lldb::TypeImplSP &type_impl_sp,
631                    uint64_t bit_offset):
632        m_type_impl_sp (type_impl_sp),
633        m_bit_offset (bit_offset),
634        m_name (),
635        m_bitfield_bit_size (0),
636        m_is_bitfield (false)
637    {
638        if (m_type_impl_sp)
639            m_name = m_type_impl_sp->GetName();
640    }
641
642    const lldb::TypeImplSP &
643    GetTypeImpl ()
644    {
645        return m_type_impl_sp;
646    }
647
648    const ConstString &
649    GetName () const
650    {
651        return m_name;
652    }
653
654    uint64_t
655    GetBitOffset () const
656    {
657        return m_bit_offset;
658    }
659
660    uint32_t
661    GetBitfieldBitSize () const
662    {
663        return m_bitfield_bit_size;
664    }
665
666    void
667    SetBitfieldBitSize (uint32_t bitfield_bit_size)
668    {
669        m_bitfield_bit_size = bitfield_bit_size;
670    }
671
672    bool
673    GetIsBitfield () const
674    {
675        return m_is_bitfield;
676    }
677
678    void
679    SetIsBitfield (bool is_bitfield)
680    {
681        m_is_bitfield = is_bitfield;
682    }
683
684protected:
685    lldb::TypeImplSP m_type_impl_sp;
686    uint64_t m_bit_offset;
687    ConstString m_name;
688    uint32_t m_bitfield_bit_size; // Bit size for bitfield members only
689    bool m_is_bitfield;
690};
691
692
693///
694/// Sometimes you can find the name of the type corresponding to an object, but we don't have debug
695/// information for it.  If that is the case, you can return one of these objects, and then if it
696/// has a full type, you can use that, but if not at least you can print the name for informational
697/// purposes.
698///
699
700class TypeAndOrName
701{
702public:
703    TypeAndOrName ();
704    TypeAndOrName (lldb::TypeSP &type_sp);
705    TypeAndOrName (const ClangASTType &clang_type);
706    TypeAndOrName (const char *type_str);
707    TypeAndOrName (const TypeAndOrName &rhs);
708    TypeAndOrName (ConstString &type_const_string);
709
710    TypeAndOrName &
711    operator= (const TypeAndOrName &rhs);
712
713    bool
714    operator==(const TypeAndOrName &other) const;
715
716    bool
717    operator!=(const TypeAndOrName &other) const;
718
719    ConstString GetName () const;
720
721    lldb::TypeSP
722    GetTypeSP () const
723    {
724        return m_type_pair.GetTypeSP();
725    }
726
727    ClangASTType
728    GetClangASTType () const
729    {
730        return m_type_pair.GetClangASTType();
731    }
732
733    void
734    SetName (const ConstString &type_name);
735
736    void
737    SetName (const char *type_name_cstr);
738
739    void
740    SetTypeSP (lldb::TypeSP type_sp);
741
742    void
743    SetClangASTType (ClangASTType clang_type);
744
745    bool
746    IsEmpty () const;
747
748    bool
749    HasName () const;
750
751    bool
752    HasTypeSP () const;
753
754    bool
755    HasClangASTType () const;
756
757    bool
758    HasType () const
759    {
760        return HasTypeSP() || HasClangASTType();
761    }
762
763    void
764    Clear ();
765
766    explicit operator bool ()
767    {
768        return !IsEmpty();
769    }
770
771private:
772    TypePair m_type_pair;
773    ConstString m_type_name;
774};
775
776} // namespace lldb_private
777
778#endif  // liblldb_Type_h_
779
780