1 //===-- ClangExternalASTSourceCommon.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_ClangExternalASTSourceCommon_h
11 #define liblldb_ClangExternalASTSourceCommon_h
12 
13 // Clang headers like to use NDEBUG inside of them to enable/disable debug
14 // releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
15 // or another. This is bad because it means that if clang was built in release
16 // mode, it assumes that you are building in release mode which is not always
17 // the case. You can end up with functions that are defined as empty in header
18 // files when NDEBUG is not defined, and this can cause link errors with the
19 // clang .a files that you have since you might be missing functions in the .a
20 // file. So we have to define NDEBUG when including clang headers to avoid any
21 // mismatches. This is covered by rdar://problem/8691220
22 
23 #if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
24 #define LLDB_DEFINED_NDEBUG_FOR_CLANG
25 #define NDEBUG
26 // Need to include assert.h so it is as clang would expect it to be (disabled)
27 #include <assert.h>
28 #endif
29 
30 #include "clang/AST/ExternalASTSource.h"
31 
32 #ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
33 #undef NDEBUG
34 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
35 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
36 #include <assert.h>
37 #endif
38 
39 #include "lldb/lldb-defines.h"
40 #include "lldb/lldb-enumerations.h"
41 #include "lldb/Core/dwarf.h"
42 
43 namespace lldb_private {
44 
45 class ClangASTMetadata
46 {
47 public:
ClangASTMetadata()48     ClangASTMetadata () :
49         m_user_id(0),
50         m_union_is_user_id(false),
51         m_union_is_isa_ptr(false),
52         m_has_object_ptr(false),
53         m_is_self (false),
54         m_is_dynamic_cxx (true)
55     {
56     }
57 
58     bool
GetIsDynamicCXXType()59     GetIsDynamicCXXType () const
60     {
61         return m_is_dynamic_cxx;
62     }
63 
64     void
SetIsDynamicCXXType(bool b)65     SetIsDynamicCXXType (bool b)
66     {
67         m_is_dynamic_cxx = b;
68     }
69 
70     void
SetUserID(lldb::user_id_t user_id)71     SetUserID (lldb::user_id_t user_id)
72     {
73         m_user_id = user_id;
74         m_union_is_user_id = true;
75         m_union_is_isa_ptr = false;
76     }
77 
78     lldb::user_id_t
GetUserID()79     GetUserID () const
80     {
81         if (m_union_is_user_id)
82             return m_user_id;
83         else
84             return LLDB_INVALID_UID;
85     }
86 
87     void
SetISAPtr(uint64_t isa_ptr)88     SetISAPtr (uint64_t isa_ptr)
89     {
90         m_isa_ptr = isa_ptr;
91         m_union_is_user_id = false;
92         m_union_is_isa_ptr = true;
93     }
94 
95     uint64_t
GetISAPtr()96     GetISAPtr () const
97     {
98         if (m_union_is_isa_ptr)
99             return m_isa_ptr;
100         else
101             return 0;
102     }
103 
104     void
SetObjectPtrName(const char * name)105     SetObjectPtrName(const char *name)
106     {
107         m_has_object_ptr = true;
108         if (strcmp (name, "self") == 0)
109             m_is_self = true;
110         else if (strcmp (name, "this") == 0)
111             m_is_self = false;
112         else
113             m_has_object_ptr = false;
114     }
115 
116     lldb::LanguageType
GetObjectPtrLanguage()117     GetObjectPtrLanguage () const
118     {
119         if (m_has_object_ptr)
120         {
121             if (m_is_self)
122                 return lldb::eLanguageTypeObjC;
123             else
124                 return lldb::eLanguageTypeC_plus_plus;
125         }
126         return lldb::eLanguageTypeUnknown;
127 
128     }
129     const char *
GetObjectPtrName()130     GetObjectPtrName() const
131     {
132         if (m_has_object_ptr)
133         {
134             if (m_is_self)
135                 return "self";
136             else
137                 return "this";
138         }
139         else
140             return NULL;
141     }
142 
143     bool
HasObjectPtr()144     HasObjectPtr() const
145     {
146         return m_has_object_ptr;
147     }
148 
149     void
150     Dump (Stream *s);
151 
152 private:
153     union
154     {
155         lldb::user_id_t m_user_id;
156         uint64_t  m_isa_ptr;
157     };
158     bool m_union_is_user_id : 1,
159          m_union_is_isa_ptr : 1,
160          m_has_object_ptr : 1,
161          m_is_self : 1,
162          m_is_dynamic_cxx : 1;
163 
164 };
165 
166 class ClangExternalASTSourceCommon : public clang::ExternalASTSource
167 {
168 public:
169     ClangExternalASTSourceCommon();
170     ~ClangExternalASTSourceCommon();
171 
172     virtual ClangASTMetadata *GetMetadata(const void *object);
173     virtual void SetMetadata(const void *object, ClangASTMetadata &metadata);
174     virtual bool HasMetadata(const void *object);
175 private:
176     typedef llvm::DenseMap<const void *, ClangASTMetadata> MetadataMap;
177 
178     MetadataMap m_metadata;
179     uint64_t    m_magic;        ///< Because we don't have RTTI, we must take it
180                                 ///< on faith that any valid ExternalASTSource that
181                                 ///< we try to use the *Metadata APIs on inherits
182                                 ///< from ClangExternalASTSourceCommon.  This magic
183                                 ///< number exists to enforce that.
184 };
185 
186 }
187 
188 #endif
189