1 //===-- ClangASTImporter.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_ClangASTImporter_h_ 11 #define liblldb_ClangASTImporter_h_ 12 13 #include <map> 14 #include <set> 15 16 #include "lldb/lldb-types.h" 17 #include "clang/AST/ASTImporter.h" 18 #include "clang/Basic/FileManager.h" 19 #include "clang/Basic/FileSystemOptions.h" 20 #include "lldb/Symbol/ClangNamespaceDecl.h" 21 22 namespace lldb_private { 23 24 class ClangASTMetrics 25 { 26 public: 27 static void DumpCounters (Log *log); 28 static void ClearLocalCounters () 29 { 30 local_counters = { 0, 0, 0, 0, 0, 0 }; 31 } 32 33 static void RegisterVisibleQuery () 34 { 35 ++global_counters.m_visible_query_count; 36 ++local_counters.m_visible_query_count; 37 } 38 39 static void RegisterLexicalQuery () 40 { 41 ++global_counters.m_lexical_query_count; 42 ++local_counters.m_lexical_query_count; 43 } 44 45 static void RegisterLLDBImport () 46 { 47 ++global_counters.m_lldb_import_count; 48 ++local_counters.m_lldb_import_count; 49 } 50 51 static void RegisterClangImport () 52 { 53 ++global_counters.m_clang_import_count; 54 ++local_counters.m_clang_import_count; 55 } 56 57 static void RegisterDeclCompletion () 58 { 59 ++global_counters.m_decls_completed_count; 60 ++local_counters.m_decls_completed_count; 61 } 62 63 static void RegisterRecordLayout () 64 { 65 ++global_counters.m_record_layout_count; 66 ++local_counters.m_record_layout_count; 67 } 68 69 private: 70 struct Counters 71 { 72 uint64_t m_visible_query_count; 73 uint64_t m_lexical_query_count; 74 uint64_t m_lldb_import_count; 75 uint64_t m_clang_import_count; 76 uint64_t m_decls_completed_count; 77 uint64_t m_record_layout_count; 78 }; 79 80 static Counters global_counters; 81 static Counters local_counters; 82 83 static void DumpCounters (Log *log, Counters &counters); 84 }; 85 86 class ClangASTImporter 87 { 88 public: 89 ClangASTImporter () : 90 m_file_manager(clang::FileSystemOptions()) 91 { 92 } 93 94 clang::QualType 95 CopyType (clang::ASTContext *dst_ctx, 96 clang::ASTContext *src_ctx, 97 clang::QualType type); 98 99 lldb::clang_type_t 100 CopyType (clang::ASTContext *dst_ctx, 101 clang::ASTContext *src_ctx, 102 lldb::clang_type_t type); 103 104 clang::Decl * 105 CopyDecl (clang::ASTContext *dst_ctx, 106 clang::ASTContext *src_ctx, 107 clang::Decl *decl); 108 109 lldb::clang_type_t 110 DeportType (clang::ASTContext *dst_ctx, 111 clang::ASTContext *src_ctx, 112 lldb::clang_type_t type); 113 114 clang::Decl * 115 DeportDecl (clang::ASTContext *dst_ctx, 116 clang::ASTContext *src_ctx, 117 clang::Decl *decl); 118 119 void 120 CompleteDecl (clang::Decl *decl); 121 122 bool 123 CompleteTagDecl (clang::TagDecl *decl); 124 125 bool 126 CompleteTagDeclWithOrigin (clang::TagDecl *decl, clang::TagDecl *origin); 127 128 bool 129 CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl); 130 131 bool 132 RequireCompleteType (clang::QualType type); 133 134 bool 135 ResolveDeclOrigin (const clang::Decl *decl, clang::Decl **original_decl, clang::ASTContext **original_ctx) 136 { 137 DeclOrigin origin = GetDeclOrigin(decl); 138 139 if (original_decl) 140 *original_decl = origin.decl; 141 142 if (original_ctx) 143 *original_ctx = origin.ctx; 144 145 return origin.Valid(); 146 } 147 148 void 149 SetDeclOrigin (const clang::Decl *decl, clang::Decl *original_decl); 150 151 ClangASTMetadata * 152 GetDeclMetadata (const clang::Decl *decl); 153 154 // 155 // Namespace maps 156 // 157 158 typedef std::vector < std::pair<lldb::ModuleSP, ClangNamespaceDecl> > NamespaceMap; 159 typedef std::shared_ptr<NamespaceMap> NamespaceMapSP; 160 161 void RegisterNamespaceMap (const clang::NamespaceDecl *decl, 162 NamespaceMapSP &namespace_map); 163 164 NamespaceMapSP GetNamespaceMap (const clang::NamespaceDecl *decl); 165 166 void BuildNamespaceMap (const clang::NamespaceDecl *decl); 167 168 // 169 // Comleters for maps 170 // 171 172 class MapCompleter 173 { 174 public: 175 virtual ~MapCompleter (); 176 177 virtual void CompleteNamespaceMap (NamespaceMapSP &namespace_map, 178 const ConstString &name, 179 NamespaceMapSP &parent_map) const = 0; 180 }; 181 182 void InstallMapCompleter (clang::ASTContext *dst_ctx, MapCompleter &completer) 183 { 184 ASTContextMetadataSP context_md; 185 ContextMetadataMap::iterator context_md_iter = m_metadata_map.find(dst_ctx); 186 187 if (context_md_iter == m_metadata_map.end()) 188 { 189 context_md = ASTContextMetadataSP(new ASTContextMetadata(dst_ctx)); 190 m_metadata_map[dst_ctx] = context_md; 191 } 192 else 193 { 194 context_md = context_md_iter->second; 195 } 196 197 context_md->m_map_completer = &completer; 198 } 199 200 void ForgetDestination (clang::ASTContext *dst_ctx); 201 void ForgetSource (clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx); 202 private: 203 struct DeclOrigin 204 { 205 DeclOrigin () : 206 ctx(NULL), 207 decl(NULL) 208 { 209 } 210 211 DeclOrigin (clang::ASTContext *_ctx, 212 clang::Decl *_decl) : 213 ctx(_ctx), 214 decl(_decl) 215 { 216 } 217 218 DeclOrigin (const DeclOrigin &rhs) 219 { 220 ctx = rhs.ctx; 221 decl = rhs.decl; 222 } 223 224 void operator= (const DeclOrigin &rhs) 225 { 226 ctx = rhs.ctx; 227 decl = rhs.decl; 228 } 229 230 bool 231 Valid () 232 { 233 return (ctx != NULL || decl != NULL); 234 } 235 236 clang::ASTContext *ctx; 237 clang::Decl *decl; 238 }; 239 240 typedef std::map<const clang::Decl *, DeclOrigin> OriginMap; 241 242 class Minion : public clang::ASTImporter 243 { 244 public: 245 Minion (ClangASTImporter &master, 246 clang::ASTContext *target_ctx, 247 clang::ASTContext *source_ctx) : 248 clang::ASTImporter(*target_ctx, 249 master.m_file_manager, 250 *source_ctx, 251 master.m_file_manager, 252 true /*minimal*/), 253 m_decls_to_deport(NULL), 254 m_decls_already_deported(NULL), 255 m_master(master), 256 m_source_ctx(source_ctx) 257 { 258 } 259 260 // A call to "InitDeportWorkQueues" puts the minion into deport mode. 261 // In deport mode, every copied Decl that could require completion is 262 // recorded and placed into the decls_to_deport set. 263 // 264 // A call to "ExecuteDeportWorkQueues" completes all the Decls that 265 // are in decls_to_deport, adding any Decls it sees along the way that 266 // it hasn't already deported. It proceeds until decls_to_deport is 267 // empty. 268 // 269 // These calls must be paired. Leaving a minion in deport mode or 270 // trying to start deport minion with a new pair of queues will result 271 // in an assertion failure. 272 273 void InitDeportWorkQueues (std::set<clang::NamedDecl *> *decls_to_deport, 274 std::set<clang::NamedDecl *> *decls_already_deported); 275 void ExecuteDeportWorkQueues (); 276 277 void ImportDefinitionTo (clang::Decl *to, clang::Decl *from); 278 279 clang::Decl *Imported (clang::Decl *from, clang::Decl *to); 280 281 std::set<clang::NamedDecl *> *m_decls_to_deport; 282 std::set<clang::NamedDecl *> *m_decls_already_deported; 283 ClangASTImporter &m_master; 284 clang::ASTContext *m_source_ctx; 285 }; 286 287 typedef std::shared_ptr<Minion> MinionSP; 288 typedef std::map<clang::ASTContext *, MinionSP> MinionMap; 289 typedef std::map<const clang::NamespaceDecl *, NamespaceMapSP> NamespaceMetaMap; 290 291 struct ASTContextMetadata 292 { 293 ASTContextMetadata(clang::ASTContext *dst_ctx) : 294 m_dst_ctx (dst_ctx), 295 m_minions (), 296 m_origins (), 297 m_namespace_maps (), 298 m_map_completer (NULL) 299 { 300 } 301 302 clang::ASTContext *m_dst_ctx; 303 MinionMap m_minions; 304 OriginMap m_origins; 305 306 NamespaceMetaMap m_namespace_maps; 307 MapCompleter *m_map_completer; 308 }; 309 310 typedef std::shared_ptr<ASTContextMetadata> ASTContextMetadataSP; 311 typedef std::map<const clang::ASTContext *, ASTContextMetadataSP> ContextMetadataMap; 312 313 ContextMetadataMap m_metadata_map; 314 315 ASTContextMetadataSP 316 GetContextMetadata (clang::ASTContext *dst_ctx) 317 { 318 ContextMetadataMap::iterator context_md_iter = m_metadata_map.find(dst_ctx); 319 320 if (context_md_iter == m_metadata_map.end()) 321 { 322 ASTContextMetadataSP context_md = ASTContextMetadataSP(new ASTContextMetadata(dst_ctx)); 323 m_metadata_map[dst_ctx] = context_md; 324 return context_md; 325 } 326 else 327 { 328 return context_md_iter->second; 329 } 330 } 331 332 ASTContextMetadataSP 333 MaybeGetContextMetadata (clang::ASTContext *dst_ctx) 334 { 335 ContextMetadataMap::iterator context_md_iter = m_metadata_map.find(dst_ctx); 336 337 if (context_md_iter != m_metadata_map.end()) 338 return context_md_iter->second; 339 else 340 return ASTContextMetadataSP(); 341 } 342 343 MinionSP 344 GetMinion (clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx) 345 { 346 ASTContextMetadataSP context_md = GetContextMetadata(dst_ctx); 347 348 MinionMap &minions = context_md->m_minions; 349 MinionMap::iterator minion_iter = minions.find(src_ctx); 350 351 if (minion_iter == minions.end()) 352 { 353 MinionSP minion = MinionSP(new Minion(*this, dst_ctx, src_ctx)); 354 minions[src_ctx] = minion; 355 return minion; 356 } 357 else 358 { 359 return minion_iter->second; 360 } 361 } 362 363 DeclOrigin 364 GetDeclOrigin (const clang::Decl *decl); 365 366 clang::FileManager m_file_manager; 367 }; 368 369 } 370 371 #endif 372
