Decouple ClangASTContext from DWARF

[zturner]

Summary

This patch attempts to remove the coupling between ClangASTContext and DWARF debug information. Previously, TypeSystem exposed a method called GetDWARFParser, which means that any TypeSystem had to have some concept of DWARF. If we want to implement a PDB TypeSystem though, it doesn't make sense to support DWARF, and we don't want to go adding something like GetPDBParser to the generic TypeSystem either.

This patch removes all of this code from TypeSystem and implements it specifically on ClangASTContext. SymbolFileDWARF and related classes (which are all DWARF specific anyway) can now use llvm casting mechanics to check if the TypeSystem is a ClangASTContext, and if so it can use GetDWARFParser.

In a followup patch, this will allow PDB and DWARF debug information to in theory live side by side for the same module.

This patch doesn't introduce a PDBASTParser yet, it just lays the framework to make this possible in a followup patch.

[clayborg]

After our last conversation I must have missed that both Go and Java need to be able to provide custom DWARF parsing. Any language, and any TypeSystem, should be able to provide a DWARFASTParser. They don't have to, but they can. So we will need to revert ALL the changes that remove the GetDWARFParser from the TypeSystem and restore them.

This patch them becomes a method to factor the clang::ExternalASTSource stuff only so that you will be able to use it in the SymbolFilePDB. Sorry for the confusion..

include/lldb/Symbol/ClangASTContext.h

37–39 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

69–71 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

521–526 ↗

(On Diff #51356)

We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

1228 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

include/lldb/Symbol/GoASTContext.h

63–64 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

390 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

include/lldb/Symbol/JavaASTContext.h

61–63 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

371 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

include/lldb/Symbol/TypeSystem.h

31 ↗

(On Diff #51356)

This line can still go as it isn't needed.

32 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

102–107 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

source/Plugins/SymbolFile/DWARF/DWARFDIE.cpp

12–30 ↗

(On Diff #51356)

Revert all changes in this file. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

408–415 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

57 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

997–1000 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

1465–1469 ↗

(On Diff #51356)

Revert. We will need to restore this since Go and Java TypeSystem subclasses need to provide DWARF parsers that translate the DWARF into types for those languages in their type systems. This is my fault.. So just leave this as is.

1617–1625 ↗

(On Diff #51356)

Revert unless you need to route this to your new Clang external source changes you made.

1635–1638 ↗

(On Diff #51356)

revert.

3828–3846 ↗

(On Diff #51356)

revert

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.h

246 ↗

(On Diff #51356)

Revert. Whitespace only change

source/Symbol/GoASTContext.cpp

1642–1649 ↗

(On Diff #51356)

revert

source/Symbol/JavaASTContext.cpp

499–506 ↗

(On Diff #51356)

revert

[zturner]

Should we go back to my original patch then? It left the parser accessible
from TypeSystem, but made it a DebugInfoParser instead of a DWARFParser.

The whole idea is to remove knowledge of a specific debug info format from
the generic TypeSystem, so it still seems wrong to add DWARF specific stuff
to TypeSystem.

One option is to add back the SymbolFormat enum and make a method in
TypeSystem like

DebugInfoASTParser *
GetASTParserForDebugFormat(SymbolFormat format)

This way it's not DWARF specific.

Another option is to add a method for pdb and a method for DWARF. I think
the former is more flexible though.

[clayborg]

No. Keep GetDWARFParser() on TypeSystem and all that code as is. You shouldn't need to add GetPDBParser() to TypeSystem as you should get a type system for language from within your SymbolFilePDB (with a language like C or C++) and then make a PDBParser with a reference to your ClangASTContext. So no one else should need to know. The main reason we get the DWARF parser from the type system is we have 2 ways to have DWARF with references to other DWARF files like the MacOSX DWARF in .o files with a debug map where each .o file is a separate SymbolFileDWARF, but they all need to use the common ClangASTContext, so we can't just have each SymbolFileDWARF create its own DWARFASTParser, we need to share a single one. You shouldn't have this problem with PDB since everything is within a single file. We will need to make sure the MacOSX test suite still runs clean with any changes.

[zturner]

I guess my point was just that it seems a little weird to treat DWARF specially. It's just another debug info format (albeit one that most compilers support), so by baking into the supposedly generic interface the requirement that "every type system must be able to support DWARF" seems a little strange.

I agree it solves the problem and everything will work, it just seems more correct from a design standpoint to have an enum for debug info type and expose one method called GetDebugInfoParser that takes the enum.

[clayborg]

I

In D18381#381457, @zturner wrote:

I guess my point was just that it seems a little weird to treat DWARF specially. It's just another debug info format (albeit one that most compilers support), so by baking into the supposedly generic interface the requirement that "every type system must be able to support DWARF" seems a little strange.

We can change the TypeSystem version of this function to not be pure virtual, and have a default implementation that returns nullptr. I do think it is valid to have a function that says "if you want to support parsing DWARF with this type system, please return a DWARFASTParser subclass that can convert DWARF into your types". I see no problem with this.

I agree it solves the problem and everything will work, it just seems more correct from a design standpoint to have an enum for debug info type and expose one method called GetDebugInfoParser that takes the enum.

I don't agree. DWARFASTParser has very specific DWARF parsing functions on it that make no sense to anyone else. Making a enum doesn't help with this, nor does making a common base class that can't do anything for anyone. So I firmly believe this is valid. Mostly because DWARF supports so many languages and each language might have its own type system. A single DWARF file could have Java, C, C++, and Go all in the same DWARF file. Each type system can provide its own DWARFASTParser. Take a look at the DWARFASTParser, most of it is very DWARF specific.

[zturner]

This patch has gotten both bigger and smaller. Smaller in the sense that after taking into consideration the most recent comments, there was really only one piece left of my patch. It is the piece that abstracted out CanComplete, CompleteType, and LayoutRecord into a new class called ClangTypeImportHelper so that the same code could be re-used by PDBASTParser.

But upon closer inspection, this code ultimately just contained multiple levels of indirection to do what seems to be better housed inside of ClangASTImporter. I mean, ClangASTImporter::Import(), makes sense right? Physically, there's no real different in doing it this way versus the other way. In both cases the DWARFASTParserClang had an instance of the thing. Both the ClangASTImporter and the ClangTypeImportHelper with my first patch, and just a ClangASTImporter with my second patch. But the code is much cleaner and more straightforward now, with fewer ping-ponging of API calls to get to the right place now that those 3 functions live directly isnide of ClangASTImporter.

In doing so though, I had some difficulty with the circular dependency relationship between ClangASTImporter and ClangASTContext. They were each calling into each other in some cases, and this was leaking into header files causing compiler errors. To address this I identified the code that needed to be shared (a couple of static methods in ClangASTContext) and moved them into a new file called ClangUtil.

Unfortunately this dirties up the CL and makes it look really large, even though a lot of the changes are just namespace fixes.

There are still many many instances of this kind of thing remaining in ClangASTContext which i did not address (because it quickly would have made the CL un-reviewable), but I would like to continue cleaning this up in subsequent patches. ClangASTContext.cpp is a massive file, and anything we can do to split this code up will help people maintain this code (not to mention help new people grok it). Plus removing circular dependencies is always a win.

[clayborg]

A few things in inlined comments, but this is very close.

source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

36 ↗

(On Diff #51476)

Can probably do this later when there are changes to this file other than clang format only changes.

42 ↗

(On Diff #51476)

Can probably do this later when there are changes to this file other than clang format only changes.

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1614–1622 ↗

(On Diff #51476)

This can be reverted since GetDWARFParser is stying in TypeSystem

[zturner]

source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

1614–1622 ↗

(On Diff #51476)

Ahh, you've actually alerted me to a subtle bug. CanCompleteType and CompleteType are not even implemented by DWARFASTParserClang anymore, because they were just forwards into the ClangASTImporter. So instead people are expected to call ast_parser->GetClangASTImporter().CanImport() or ast_parser->GetClangASTImporter().Import(). So the code here is actually calling the CanCompleteType method in the base class DWARFASTParser which simply returns false.

So I'll need to change this to delete the empty implementations from the base class, and call straight into the ClangASTImporter.

[zturner]

Fixes issue with CanCompleteType being unimplemented. This update deletes CanCompleteType and CompleteType from DWARFASTParser base class, and users of that function now call GetClangASTImporter().CanImport() and GetClangASTImporter().CompleteType().

[clayborg]

I will need to run the MacOSX test suite on this before I can give it the OK. I won't be able to do this today, but might be able to get to it tomorrow. If you can run the MacOSX test suite, let me know.

[zturner]

It's been a while since I've used my Mac. I'll fire it up and see if I can get it going, but no promises. I'll update tomorrow

[zturner]

Having trouble building on OSX.

ERROR:root:Unable to find swig executable: 'module' object has no attribute
'OSError'

Command /bin/sh failed with exit code 250

But "which swig" finds it just fine. It's been a long time since I've
built on OSX so I don't know if something has changed.

In any case, let me know if there's something I should be doing.

[zturner]

Update patch.

[zturner]

Rebased against ToT

[zturner]

Hi Greg, are you going to have a chance to try this out today?

lldb/trunk/include/lldb/Symbol/ClangASTContext.h

 
 // Other libraries and framework includes
 #include "llvm/ADT/SmallVector.h"
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/TemplateBase.h"
 
 // Project includes
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
-#include "lldb/lldb-enumerations.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/TypeSystem.h"
+#include "lldb/lldb-enumerations.h"
+
+class DWARFASTParserClang;
 
 namespace lldb_private {
 
 class Declaration;
 
 class ClangASTContext : public TypeSystem
 {
 public:
public:
     static CompilerType
     GetFloatTypeFromBitSize (clang::ASTContext *ast,
                              size_t bit_size);
 
     //------------------------------------------------------------------
     // TypeSystem methods
     //------------------------------------------------------------------
     DWARFASTParser *
-    GetDWARFParser () override;
+    GetDWARFParser() override;
 
     //------------------------------------------------------------------
     // ClangASTContext callbacks for external source lookups.
     //------------------------------------------------------------------
     static void
     CompleteTagDecl (void *baton, clang::TagDecl *);
 
     static void
public:
 
     bool
     DeclContextIsClassMethod (void *opaque_decl_ctx,
                               lldb::LanguageType *language_ptr,
                               bool *is_instance_method_ptr,
                               ConstString *language_object_name_ptr) override;
 
     //----------------------------------------------------------------------
-    // Clang specific CompilerType predicates
-    //----------------------------------------------------------------------
-    
-    static bool
-    IsClangType (const CompilerType &ct)
-    {
-        return llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) != nullptr && ct.GetOpaqueQualType() != nullptr;
-    }
-
-    //----------------------------------------------------------------------
     // Clang specific clang::DeclContext functions
     //----------------------------------------------------------------------
 
     static clang::DeclContext *
     DeclContextGetAsDeclContext (const CompilerDeclContext &dc);
 
     static clang::ObjCMethodDecl *
     DeclContextGetAsObjCMethodDecl (const CompilerDeclContext &dc);
public:
     AddRestrictModifier (lldb::opaque_compiler_type_t type) override;
 
     CompilerType
     CreateTypedef (lldb::opaque_compiler_type_t type, const char *name, const CompilerDeclContext &decl_ctx) override;
 
     // If the current object represents a typedef type, get the underlying type
     CompilerType
     GetTypedefedType (lldb::opaque_compiler_type_t type) override;
     
-    static CompilerType
-    RemoveFastQualifiers (const CompilerType& type);
-    
     //----------------------------------------------------------------------
     // Create related types using the current type's AST
     //----------------------------------------------------------------------
     CompilerType
     GetBasicTypeFromAST (lldb::BasicType basic_type) override;
     
     //----------------------------------------------------------------------
     // Exploring the type
AddMethodToObjCObjectType (const CompilerType& type,
                                const char *name,  // the full symbol name as seen in the symbol table (lldb::opaque_compiler_type_t type, "-[NString stringWithCString:]")
                                const CompilerType &method_compiler_type,
                                lldb::AccessType access,
                                bool is_artificial);
     
     static bool
     SetHasExternalStorage (lldb::opaque_compiler_type_t type, bool has_extern);
     
-
-    static bool
-    CanImport (const CompilerType &type, lldb_private::ClangASTImporter &importer);
-
-    static bool
-    Import (const CompilerType &type, lldb_private::ClangASTImporter &importer);
-
     static bool
     GetHasExternalStorage (const CompilerType &type);
     //------------------------------------------------------------------
     // Tag Declarations
     //------------------------------------------------------------------
     static bool
     StartTagDeclarationDefinition (const CompilerType &type);
     
#define LLDB_INVALID_DECL_LEVEL            UINT32_MAX
     static clang::TagDecl *
     GetAsTagDecl (const CompilerType& type);
 
     clang::CXXRecordDecl *
     GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type);
     
     static clang::ObjCInterfaceDecl *
     GetAsObjCInterfaceDecl (const CompilerType& type);
-    
-    static clang::QualType
-    GetQualType (const CompilerType& type)
-    {
-        // Make sure we have a clang type before making a clang::QualType
-        if (type.GetOpaqueQualType())
-        {
-            ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
-            if (ast)
-                return clang::QualType::getFromOpaquePtr(type.GetOpaqueQualType());
-        }
-        return clang::QualType();
-    }
-
-    static clang::QualType
-    GetCanonicalQualType (const CompilerType& type)
-    {
-        // Make sure we have a clang type before making a clang::QualType
-        ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type.GetTypeSystem());
-        if (ast)
-            return clang::QualType::getFromOpaquePtr(type.GetOpaqueQualType()).getCanonicalType();
-        return clang::QualType();
-    }
-
     clang::ClassTemplateDecl *
     ParseClassTemplateDecl (clang::DeclContext *decl_ctx,
                             lldb::AccessType access_type,
                             const char *parent_name,
                             int tag_decl_kind,
                             const ClangASTContext::TemplateParameterInfos &template_param_infos);
 
     clang::BlockDecl *
GetCanonicalQualType (lldb::opaque_compiler_type_t type)
         if (type)
             return clang::QualType::getFromOpaquePtr(type).getCanonicalType();
         return clang::QualType();
     }
 
     //------------------------------------------------------------------
     // Classes that inherit from ClangASTContext can see and modify these
     //------------------------------------------------------------------
+    // clang-format off
     std::string                                     m_target_triple;
     std::unique_ptr<clang::ASTContext>              m_ast_ap;
     std::unique_ptr<clang::LangOptions>             m_language_options_ap;
     std::unique_ptr<clang::FileManager>             m_file_manager_ap;
     std::unique_ptr<clang::FileSystemOptions>       m_file_system_options_ap;
     std::unique_ptr<clang::SourceManager>           m_source_manager_ap;
     std::unique_ptr<clang::DiagnosticsEngine>       m_diagnostics_engine_ap;
     std::unique_ptr<clang::DiagnosticConsumer>      m_diagnostic_consumer_ap;
     std::shared_ptr<clang::TargetOptions>           m_target_options_rp;
     std::unique_ptr<clang::TargetInfo>              m_target_info_ap;
     std::unique_ptr<clang::IdentifierTable>         m_identifier_table_ap;
     std::unique_ptr<clang::SelectorTable>           m_selector_table_ap;
     std::unique_ptr<clang::Builtin::Context>        m_builtins_ap;
-    std::unique_ptr<DWARFASTParser>                 m_dwarf_ast_parser_ap;
+    std::unique_ptr<DWARFASTParserClang>            m_dwarf_ast_parser_ap;
     std::unique_ptr<ClangASTSource>                 m_scratch_ast_source_ap;
     std::unique_ptr<clang::MangleContext>           m_mangle_ctx_ap;
     CompleteTagDeclCallback                         m_callback_tag_decl;
     CompleteObjCInterfaceDeclCallback               m_callback_objc_decl;
     void *                                          m_callback_baton;
     uint32_t                                        m_pointer_byte_size;
     bool                                            m_ast_owned;
     bool                                            m_can_evaluate_expressions;
     std::map<void *, std::shared_ptr<void>>         m_decl_objects;
-
+    // clang-format on
 private:
     //------------------------------------------------------------------
     // For ClangASTContext only
     //------------------------------------------------------------------
     ClangASTContext(const ClangASTContext&);
     const ClangASTContext& operator=(const ClangASTContext&);
 };
 

lldb/trunk/include/lldb/Symbol/ClangASTImporter.h

 // C++ Includes
 #include <map>
 #include <memory>
 #include <set>
 #include <vector>
 
 // Other libraries and framework includes
 #include "clang/AST/ASTImporter.h"
+#include "clang/AST/CharUnits.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/FileSystemOptions.h"
 
 // Project includes
 #include "lldb/lldb-types.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 
+#include "llvm/ADT/DenseMap.h"
+
 namespace lldb_private {
     
 class ClangASTMetrics
 {
 public:
     static void DumpCounters (Log *log);
     static void ClearLocalCounters ()
     {
private:
     static Counters local_counters;
     
     static void DumpCounters (Log *log, Counters &counters);
 };
 
 class ClangASTImporter 
 {
 public:
+    struct LayoutInfo
+    {
+        LayoutInfo() : bit_size(0), alignment(0), field_offsets(), base_offsets(), vbase_offsets() {}
+        uint64_t bit_size;
+        uint64_t alignment;
+        llvm::DenseMap<const clang::FieldDecl *, uint64_t> field_offsets;
+        llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
+        llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> vbase_offsets;
+    };
+
     ClangASTImporter () :
         m_file_manager(clang::FileSystemOptions())
     {
     }
     
     clang::QualType
     CopyType (clang::ASTContext *dst_ctx,
               clang::ASTContext *src_ctx,
public:
     DeportType (clang::ASTContext *dst_ctx,
                 clang::ASTContext *src_ctx,
                 lldb::opaque_compiler_type_t type);
     
     clang::Decl *
     DeportDecl (clang::ASTContext *dst_ctx,
                 clang::ASTContext *src_ctx,
                 clang::Decl *decl);
-    
     void
-    CompleteDecl (clang::Decl *decl);
-        
+    InsertRecordDecl(clang::RecordDecl *decl, const LayoutInfo &layout);
+
+    bool
+    LayoutRecordType(const clang::RecordDecl *record_decl, uint64_t &bit_size, uint64_t &alignment,
+                     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
+                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
+                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets);
+
+    bool
+    CanImport(const CompilerType &type);
+
+    bool
+    Import(const CompilerType &type);
+
+    bool
+    CompleteType(const CompilerType &compiler_type);
+
+    void
+    CompleteDecl(clang::Decl *decl);
     bool
     CompleteTagDecl (clang::TagDecl *decl);
     
     bool
     CompleteTagDeclWithOrigin (clang::TagDecl *decl, clang::TagDecl *origin);
     
     bool
     CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl);
GetMinion (clang::ASTContext *dst_ctx, clang::ASTContext *src_ctx)
             return minion_iter->second;
         }       
     }
     
     DeclOrigin
     GetDeclOrigin (const clang::Decl *decl);
         
     clang::FileManager      m_file_manager;
+    typedef llvm::DenseMap<const clang::RecordDecl *, LayoutInfo> RecordDeclToLayoutMap;
+
+    RecordDeclToLayoutMap m_record_decl_to_layout_map;
 };
     
 } // namespace lldb_private
 
 #endif // liblldb_ClangASTImporter_h_

lldb/trunk/include/lldb/Symbol/ClangUtil.h

+//===-- ClangUtil.h ---------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+// A collection of helper methods and data structures for manipulating clang
+// types and decls.
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_SYMBOL_CLANGUTIL_H
+#define LLDB_SYMBOL_CLANGUTIL_H
+
+#include "clang/AST/Type.h"
+
+#include "lldb/Symbol/CompilerType.h"
+
+namespace lldb_private
+{
+struct ClangUtil
+{
+    static bool
+    IsClangType(const CompilerType &ct);
+
+    static clang::QualType
+    GetQualType(const CompilerType &ct);
+
+    static clang::QualType
+    GetCanonicalQualType(const CompilerType &ct);
+
+    static CompilerType
+    RemoveFastQualifiers(const CompilerType &ct);
+};
+}
+
+#endif

lldb/trunk/include/lldb/Symbol/TypeSystem.h

public:
 
      
     // Free up any resources associated with this TypeSystem.  Done before removing
     // all the TypeSystems from the TypeSystemMap.
     virtual void
     Finalize() {}
 
     virtual DWARFASTParser *
-    GetDWARFParser ()
+    GetDWARFParser()
     {
         return nullptr;
     }
 
     virtual SymbolFile *
     GetSymbolFile () const
     {
         return m_sym_file;

lldb/trunk/source/Plugins/ExpressionParser/Clang/ASTDumper.cpp

 //===-- ASTDumper.cpp -------------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ASTDumper.h"
 
 #include "lldb/Core/Log.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 
 #include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 
 ASTDumper::ASTDumper (clang::Decl *decl)
 {

 
 ASTDumper::ASTDumper (lldb::opaque_compiler_type_t type)
 {
     m_dump = clang::QualType::getFromOpaquePtr(type).getAsString();
 }
 
 ASTDumper::ASTDumper (const CompilerType &compiler_type)
 {
-    m_dump = ClangASTContext::GetQualType(compiler_type).getAsString();
+    m_dump = ClangUtil::GetQualType(compiler_type).getAsString();
 }
 
 
 const char *
 ASTDumper::GetCString()
 {
     return m_dump.c_str();
 }

lldb/trunk/source/Plugins/ExpressionParser/Clang/ClangASTSource.cpp

 //===-- ClangASTSource.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "ClangASTSource.h"
 
 #include "ASTDumper.h"
 #include "ClangModulesDeclVendor.h"
 
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecordLayout.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/ModuleList.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Target.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecordLayout.h"
 
 #include <vector>
 
 using namespace clang;
 using namespace lldb_private;
 
 //------------------------------------------------------------------
 // Scoped class that will remove an active lexical decl from the set
if (!m_ast_importer_sp->CompleteTagDecl (tag_decl))
                     if (!type)
                         continue;
 
                     CompilerType clang_type (type->GetFullCompilerType ());
 
                     if (!clang_type)
                         continue;
 
-                    const TagType *tag_type = ClangASTContext::GetQualType(clang_type)->getAs<TagType>();
+                    const TagType *tag_type = ClangUtil::GetQualType(clang_type)->getAs<TagType>();
 
                     if (!tag_type)
                         continue;
 
                     TagDecl *candidate_tag_decl = const_cast<TagDecl*>(tag_type->getDecl());
 
                     if (m_ast_importer_sp->CompleteTagDeclWithOrigin (tag_decl, candidate_tag_decl))
                         found = true;
if (!m_ast_importer_sp->CompleteTagDecl (tag_decl))
                 if (!type)
                     continue;
 
                 CompilerType clang_type (type->GetFullCompilerType ());
 
                 if (!clang_type)
                     continue;
 
-                const TagType *tag_type = ClangASTContext::GetQualType(clang_type)->getAs<TagType>();
+                const TagType *tag_type = ClangUtil::GetQualType(clang_type)->getAs<TagType>();
 
                 if (!tag_type)
                     continue;
 
                 TagDecl *candidate_tag_decl = const_cast<TagDecl*>(tag_type->getDecl());
 
                 // We have found a type by basename and we need to make sure the decl contexts
                 // are the same before we can try to complete this type with another
ClangASTSource::GuardedCopyType (const CompilerType &src_type)
     ClangASTContext *src_ast = llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
     if (src_ast == nullptr)
         return CompilerType();
 
     ClangASTMetrics::RegisterLLDBImport();
 
     SetImportInProgress(true);
 
-    QualType copied_qual_type = m_ast_importer_sp->CopyType (m_ast_context, src_ast->getASTContext(), ClangASTContext::GetQualType(src_type));
+    QualType copied_qual_type =
+        m_ast_importer_sp->CopyType(m_ast_context, src_ast->getASTContext(), ClangUtil::GetQualType(src_type));
 
     SetImportInProgress(false);
 
     if (copied_qual_type.getAsOpaquePtr() && copied_qual_type->getCanonicalTypeInternal().isNull())
         // this shouldn't happen, but we're hardening because the AST importer seems to be generating bad types
         // on occasion.
         return CompilerType();
 
NameSearchContext::AddVarDecl(const CompilerType &type)
     ClangASTContext* lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
     if (!lldb_ast)
         return NULL;
     
     IdentifierInfo *ii = m_decl_name.getAsIdentifierInfo();
 
     clang::ASTContext *ast = lldb_ast->getASTContext();
 
-    clang::NamedDecl *Decl = VarDecl::Create(*ast,
-                                             const_cast<DeclContext*>(m_decl_context),
-                                             SourceLocation(),
-                                             SourceLocation(),
-                                             ii,
-                                             ClangASTContext::GetQualType(type),
-                                             0,
-                                             SC_Static);
+    clang::NamedDecl *Decl = VarDecl::Create(*ast, const_cast<DeclContext *>(m_decl_context), SourceLocation(),
+                                             SourceLocation(), ii, ClangUtil::GetQualType(type), 0, SC_Static);
     m_decls.push_back(Decl);
 
     return Decl;
 }
 
 clang::NamedDecl *
 NameSearchContext::AddFunDecl (const CompilerType &type, bool extern_c)
 {
     assert (type && "Type for variable must be valid!");
 
     if (!type.IsValid())
         return NULL;
 
     if (m_function_types.count(type))
         return NULL;
     
     ClangASTContext* lldb_ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
     if (!lldb_ast)
         return NULL;
 
     m_function_types.insert(type);
 
-    QualType qual_type (ClangASTContext::GetQualType(type));
+    QualType qual_type(ClangUtil::GetQualType(type));
 
     clang::ASTContext *ast = lldb_ast->getASTContext();
 
     const bool isInlineSpecified = false;
     const bool hasWrittenPrototype = true;
     const bool isConstexprSpecified = false;
     
     clang::DeclContext *context = const_cast<DeclContext*>(m_decl_context);
NameSearchContext::AddGenericFunDecl()
     return AddFunDecl(CompilerType (m_ast_source.m_ast_context, generic_function_type), true);
 }
 
 clang::NamedDecl *
 NameSearchContext::AddTypeDecl(const CompilerType &clang_type)
 {
     if (clang_type)
     {
-        QualType qual_type = ClangASTContext::GetQualType(clang_type);
+        QualType qual_type = ClangUtil::GetQualType(clang_type);
 
         if (const TypedefType *typedef_type = llvm::dyn_cast<TypedefType>(qual_type))
         {
             TypedefNameDecl *typedef_name_decl = typedef_type->getDecl();
 
             m_decls.push_back(typedef_name_decl);
 
             return (NamedDecl*)typedef_name_decl;

lldb/trunk/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

 #include "llvm/IR/Module.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/IR/Metadata.h"
 #include "llvm/IR/ValueSymbolTable.h"
 
 #include "clang/AST/ASTContext.h"
 
-#include "lldb/Core/dwarf.h"
 #include "lldb/Core/ConstString.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamString.h"
+#include "lldb/Core/dwarf.h"
 #include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/Endian.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 
 #include <map>
 
 using namespace llvm;
 
 static char ID;
 
else if (GlobalVariable *global_variable = dyn_cast<GlobalVariable>(llvm_value_ptr))
         }
 
         const uint64_t value_size = compiler_type.GetByteSize(nullptr);
         lldb::offset_t value_alignment = (compiler_type.GetTypeBitAlign() + 7ull) / 8ull;
 
         if (log)
         {
             log->Printf("Type of \"%s\" is [clang \"%s\", llvm \"%s\"] [size %" PRIu64 ", align %" PRIu64 "]",
-                        name.c_str(),
-                        lldb_private::ClangASTContext::GetQualType(compiler_type).getAsString().c_str(),
-                        PrintType(value_type).c_str(),
-                        value_size,
-                        value_alignment);
+                        name.c_str(), lldb_private::ClangUtil::GetQualType(compiler_type).getAsString().c_str(),
+                        PrintType(value_type).c_str(), value_size, value_alignment);
         }
 
 
         if (named_decl && !m_decl_map->AddValueToStruct(named_decl,
                                                         lldb_private::ConstString (name.c_str()),
                                                         llvm_value_ptr,
                                                         value_size,
                                                         value_alignment))

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCDeclVendor.cpp

 //===-- AppleObjCDeclVendor.cpp ---------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleObjCDeclVendor.h"
 
+#include "Plugins/ExpressionParser/Clang/ASTDumper.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
-#include "Plugins/ExpressionParser/Clang/ASTDumper.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/DeclObjC.h"
 
 using namespace lldb_private;
clang::ObjCMethodDecl *BuildMethod (clang::ObjCInterfaceDecl *interface_decl, const char *name, bool instance, ObjCLanguageRuntime::EncodingToTypeSP type_realizer_sp)
             {
                 is_zero_argument = false;
                 selector_components.push_back(&ast_ctx.Idents.get(llvm::StringRef(name_cursor, colon_loc - name_cursor)));
                 name_cursor = colon_loc + 1;
             }
         }
         
         clang::Selector sel = ast_ctx.Selectors.getSelector(is_zero_argument ? 0 : selector_components.size(), selector_components.data());
-        
-        clang::QualType ret_type = ClangASTContext::GetQualType(type_realizer_sp->RealizeType(interface_decl->getASTContext(), m_type_vector[0].c_str(), for_expression));
-        
+        clang::QualType ret_type = ClangUtil::GetQualType(
+            type_realizer_sp->RealizeType(interface_decl->getASTContext(), m_type_vector[0].c_str(), for_expression));
         if (ret_type.isNull())
             return NULL;
         
         clang::ObjCMethodDecl *ret = clang::ObjCMethodDecl::Create(ast_ctx,
                                                                    clang::SourceLocation(),
                                                                    clang::SourceLocation(),
                                                                    sel,
                                                                    ret_type,
clang::ObjCMethodDecl *BuildMethod (clang::ObjCInterfaceDecl *interface_decl, const char *name, bool instance, ObjCLanguageRuntime::EncodingToTypeSP type_realizer_sp)
         
         std::vector <clang::ParmVarDecl*> parm_vars;
         
         for (size_t ai = 3, ae = m_type_vector.size();
              ai != ae;
              ++ai)
         {
             const bool for_expression = true;
-            clang::QualType arg_type = ClangASTContext::GetQualType(type_realizer_sp->RealizeType(ast_ctx, m_type_vector[ai].c_str(), for_expression));
-            
+            clang::QualType arg_type = ClangUtil::GetQualType(
+                type_realizer_sp->RealizeType(ast_ctx, m_type_vector[ai].c_str(), for_expression));
             if (arg_type.isNull())
                 return NULL; // well, we just wasted a bunch of time.  Wish we could delete the stuff we'd just made!
 
             parm_vars.push_back(clang::ParmVarDecl::Create(ast_ctx,
                                                            ret,
                                                            clang::SourceLocation(),
                                                            clang::SourceLocation(),
                                                            NULL,
auto ivar_func = [log, interface_decl, this](const char *name, const char *type, lldb::addr_t offset_ptr, uint64_t size) -> bool
             log->Printf("[  AOTV::FD] Instance variable [%s] [%s], offset at %" PRIx64, name, type, offset_ptr);
         
         CompilerType ivar_type = m_runtime.GetEncodingToType()->RealizeType(m_ast_ctx, type, for_expression);
         
         if (ivar_type.IsValid())
         {
             clang::TypeSourceInfo * const type_source_info = nullptr;
             const bool is_synthesized = false;
-            clang::ObjCIvarDecl *ivar_decl = clang::ObjCIvarDecl::Create (*m_ast_ctx.getASTContext(),
-                                                                          interface_decl,
-                                                                          clang::SourceLocation(),
-                                                                          clang::SourceLocation(),
-                                                                          &m_ast_ctx.getASTContext()->Idents.get(name),
-                                                                          ClangASTContext::GetQualType(ivar_type),
-                                                                          type_source_info,                      // TypeSourceInfo *
-                                                                          clang::ObjCIvarDecl::Public,
-                                                                          0,
-                                                                          is_synthesized);
-            
+            clang::ObjCIvarDecl *ivar_decl = clang::ObjCIvarDecl::Create(
+                *m_ast_ctx.getASTContext(), interface_decl, clang::SourceLocation(), clang::SourceLocation(),
+                &m_ast_ctx.getASTContext()->Idents.get(name), ClangUtil::GetQualType(ivar_type),
+                type_source_info, // TypeSourceInfo *
+                clang::ObjCIvarDecl::Public, 0, is_synthesized);
             if (ivar_decl)
             {
                 interface_decl->addDecl(ivar_decl);
             }
         }
         
         return false;
     };

lldb/trunk/source/Plugins/LanguageRuntime/ObjC/AppleObjCRuntime/AppleObjCTypeEncodingParser.cpp

 //===-- AppleObjCTypeEncodingParser.cpp -------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "AppleObjCTypeEncodingParser.h"
 
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StringLexer.h"
 
 #include <vector>
 
 using namespace lldb_private;
if (union_type)
                 elem_name.Printf("__unnamed_%u",count);
                 element.name = std::string(elem_name.GetData());
             }
             ClangASTContext::AddFieldToRecordType(union_type, element.name.c_str(), CompilerType(&ast_ctx, element.type), lldb::eAccessPublic, element.bitfield);
             ++count;
         }
         ClangASTContext::CompleteTagDeclarationDefinition(union_type);
     }
-    return ClangASTContext::GetQualType(union_type);
+    return ClangUtil::GetQualType(union_type);
 }
 
 clang::QualType
 AppleObjCTypeEncodingParser::BuildArray (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
 {
     if (!type.NextIf('['))
         return clang::QualType();
     uint32_t size = ReadNumber(type);
     clang::QualType element_type(BuildType(ast_ctx, type, for_expression));
     if (!type.NextIf(']'))
         return clang::QualType();
     ClangASTContext *lldb_ctx = ClangASTContext::GetASTContext(&ast_ctx);
     if (!lldb_ctx)
         return clang::QualType();
     CompilerType array_type(lldb_ctx->CreateArrayType(CompilerType(&ast_ctx, element_type), size, false));
-    return ClangASTContext::GetQualType(array_type);
+    return ClangUtil::GetQualType(array_type);
 }
 
 // the runtime can emit these in the form of @"SomeType", giving more specifics
 // this would be interesting for expression parser interop, but since we actually try
 // to avoid exposing the ivar info to the expression evaluator, consume but ignore the type info
 // and always return an 'id'; if anything, dynamic typing will resolve things for us anyway
 clang::QualType
 AppleObjCTypeEncodingParser::BuildObjCObjectPointerType (clang::ASTContext &ast_ctx, lldb_utility::StringLexer& type, bool for_expression)
if (for_expression && !name.empty())
         // The user can forward-declare something that has no definition.  The runtime doesn't prohibit this at all.
         // This is a rare and very weird case.  We keep this assert in debug builds so we catch other weird cases.
 #ifdef LLDB_CONFIGURATION_DEBUG
         assert(num_types);
 #else
         if (!num_types)
             return ast_ctx.getObjCIdType();
 #endif
-        
-        return ClangASTContext::GetQualType(ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
+        return ClangUtil::GetQualType(ClangASTContext::GetTypeForDecl(decls[0]).GetPointerType());
     }
     else
     {
         // We're going to resolve this dynamically anyway, so just smile and wave.
         return ast_ctx.getObjCIdType();
     }
 }
 

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParser.h

ParseTypeFromDWARF (const lldb_private::SymbolContext& sc,
                         lldb_private::Log *log,
                         bool *type_is_new_ptr) = 0;
 
     virtual lldb_private::Function *
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) = 0;
 
     virtual bool
-    CanCompleteType (const lldb_private::CompilerType &compiler_type)
-    {
-        return false;
-    }
-
-    virtual bool
-    CompleteType (const lldb_private::CompilerType &compiler_type)
-    {
-        return false;
-    }
-
-    virtual bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &compiler_type) = 0;
 
     virtual lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) = 0;
 
     virtual lldb_private::CompilerDeclContext

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.h

 // C++ Includes
 // Other libraries and framework includes
 #include "llvm/ADT/DenseMap.h"
 #include "llvm/ADT/SmallPtrSet.h"
 #include "llvm/ADT/SmallVector.h"
 #include "clang/AST/CharUnits.h"
 
 // Project includes
+#include "DWARFASTParser.h"
+#include "DWARFDefines.h"
 #include "lldb/Core/ClangForward.h"
 #include "lldb/Core/PluginInterface.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "DWARFDefines.h"
-#include "DWARFASTParser.h"
+#include "lldb/Symbol/ClangASTImporter.h"
 
 class DWARFDebugInfoEntry;
 class DWARFDIECollection;
 
 class DWARFASTParserClang : public DWARFASTParser
 {
 public:
     DWARFASTParserClang (lldb_private::ClangASTContext &ast);
 
     ~DWARFASTParserClang() override;
 
+    // DWARFASTParser interface.
     lldb::TypeSP
     ParseTypeFromDWARF (const lldb_private::SymbolContext& sc,
                         const DWARFDIE &die,
                         lldb_private::Log *log,
                         bool *type_is_new_ptr) override;
 
 
     lldb_private::Function *
     ParseFunctionFromDWARF (const lldb_private::SymbolContext& sc,
                             const DWARFDIE &die) override;
 
     bool
-    CanCompleteType (const lldb_private::CompilerType &compiler_type) override;
-
-    bool
-    CompleteType (const lldb_private::CompilerType &compiler_type) override;
-
-    bool
     CompleteTypeFromDWARF (const DWARFDIE &die,
                            lldb_private::Type *type,
                            lldb_private::CompilerType &compiler_type) override;
 
     lldb_private::CompilerDecl
     GetDeclForUIDFromDWARF (const DWARFDIE &die) override;
 
     std::vector<DWARFDIE>
     GetDIEForDeclContext (lldb_private::CompilerDeclContext decl_context) override;
 
     lldb_private::CompilerDeclContext
     GetDeclContextForUIDFromDWARF (const DWARFDIE &die) override;
 
     lldb_private::CompilerDeclContext
     GetDeclContextContainingUIDFromDWARF (const DWARFDIE &die) override;
 
-    bool
-    LayoutRecordType(const clang::RecordDecl *record_decl,
-                     uint64_t &bit_size,
-                     uint64_t &alignment,
-                     llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
-                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
-                     llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets);
+    lldb_private::ClangASTImporter &
+    GetClangASTImporter();
 
 protected:
     class DelayedAddObjCClassProperty;
     typedef std::vector <DelayedAddObjCClassProperty> DelayedPropertyList;
 
-    struct LayoutInfo
-    {
-        LayoutInfo () :
-        bit_size(0),
-        alignment(0),
-        field_offsets(),
-        base_offsets(),
-        vbase_offsets()
-        {
-        }
-        uint64_t bit_size;
-        uint64_t alignment;
-        llvm::DenseMap<const clang::FieldDecl *, uint64_t> field_offsets;
-        llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> base_offsets;
-        llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> vbase_offsets;
-    };
-
     clang::BlockDecl *
     ResolveBlockDIE (const DWARFDIE &die);
 
     clang::NamespaceDecl *
     ResolveNamespaceDIE (const DWARFDIE &die);
 
-    typedef llvm::DenseMap<const clang::RecordDecl *, LayoutInfo> RecordDeclToLayoutMap;
-
     bool
     ParseTemplateDIE (const DWARFDIE &die,
                       lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos);
     bool
     ParseTemplateParameterInfos (const DWARFDIE &parent_die,
                                  lldb_private::ClangASTContext::TemplateParameterInfos &template_param_infos);
 
     bool
-    ParseChildMembers (const lldb_private::SymbolContext& sc,
-                       const DWARFDIE &die,
-                       lldb_private::CompilerType &class_compiler_type,
-                       const lldb::LanguageType class_language,
-                       std::vector<clang::CXXBaseSpecifier *>& base_classes,
-                       std::vector<int>& member_accessibilities,
-                       DWARFDIECollection& member_function_dies,
-                       DelayedPropertyList& delayed_properties,
-                       lldb::AccessType &default_accessibility,
-                       bool &is_a_class,
-                       LayoutInfo &layout_info);
+    ParseChildMembers(const lldb_private::SymbolContext &sc, const DWARFDIE &die,
+                      lldb_private::CompilerType &class_compiler_type, const lldb::LanguageType class_language,
+                      std::vector<clang::CXXBaseSpecifier *> &base_classes, std::vector<int> &member_accessibilities,
+                      DWARFDIECollection &member_function_dies, DelayedPropertyList &delayed_properties,
+                      lldb::AccessType &default_accessibility, bool &is_a_class,
+                      lldb_private::ClangASTImporter::LayoutInfo &layout_info);
 
     size_t
     ParseChildParameters (const lldb_private::SymbolContext& sc,
                           clang::DeclContext *containing_decl_ctx,
                           const DWARFDIE &parent_die,
                           bool skip_artificial,
                           bool &is_static,
                           bool &is_variadic,
protected:
 
     void
     LinkDeclContextToDIE (clang::DeclContext *decl_ctx,
                           const DWARFDIE &die);
 
     void
     LinkDeclToDIE (clang::Decl *decl, const DWARFDIE &die);
 
-    lldb_private::ClangASTImporter &
-    GetClangASTImporter();
-
     lldb::TypeSP
     ParseTypeFromDWO (const DWARFDIE &die, lldb_private::Log *log);
 
     //----------------------------------------------------------------------
     // Return true if this type is a declaration to a type in an external
     // module.
     //----------------------------------------------------------------------
     lldb::ModuleSP
     GetModuleForType (const DWARFDIE &die);
 
     typedef llvm::SmallPtrSet<const DWARFDebugInfoEntry *, 4> DIEPointerSet;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::DeclContext *> DIEToDeclContextMap;
     //typedef llvm::DenseMap<const clang::DeclContext *, DIEPointerSet> DeclContextToDIEMap;
     typedef std::multimap<const clang::DeclContext *, const DWARFDIE> DeclContextToDIEMap;
     typedef llvm::DenseMap<const DWARFDebugInfoEntry *, clang::Decl *> DIEToDeclMap;
     typedef llvm::DenseMap<const clang::Decl *, DIEPointerSet> DeclToDIEMap;
 
     lldb_private::ClangASTContext &m_ast;
     DIEToDeclMap m_die_to_decl;
     DeclToDIEMap m_decl_to_die;
     DIEToDeclContextMap m_die_to_decl_ctx;
     DeclContextToDIEMap m_decl_ctx_to_die;
-    RecordDeclToLayoutMap m_record_decl_to_layout_map;
     std::unique_ptr<lldb_private::ClangASTImporter> m_clang_ast_importer_ap;
 };
 
 #endif // SymbolFileDWARF_DWARFASTParserClang_h_

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFASTParserClang.cpp

 #include "DWARFDeclContext.h"
 #include "DWARFDefines.h"
 #include "DWARFDIE.h"
 #include "DWARFDIECollection.h"
 #include "SymbolFileDWARF.h"
 #include "SymbolFileDWARFDebugMap.h"
 #include "UniqueDWARFASTType.h"
 
-#include "lldb/Interpreter/Args.h"
+#include "Plugins/Language/ObjC/ObjCLanguage.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/Value.h"
 #include "lldb/Host/Host.h"
+#include "lldb/Interpreter/Args.h"
 #include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/Function.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Symbol/TypeMap.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBAssert.h"
-#include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "clang/AST/DeclCXX.h"
 #include "clang/AST/DeclObjC.h"
 
 #include <map>
 #include <vector>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
if (die)
                             ClangASTContext::StartTagDeclarationDefinition (clang_type);
                             ClangASTContext::CompleteTagDeclarationDefinition (clang_type);
 
                             if (tag == DW_TAG_structure_type) // this only applies in C
                             {
                                 clang::RecordDecl *record_decl = ClangASTContext::GetAsRecordDecl(clang_type);
 
                                 if (record_decl)
-                                    m_record_decl_to_layout_map.insert(std::make_pair(record_decl, LayoutInfo()));
+                                {
+                                    GetClangASTImporter().InsertRecordDecl(record_decl, ClangASTImporter::LayoutInfo());
+                                }
                             }
                         }
                         else if (clang_type_was_created)
                         {
                             // Start the definition if the class is not objective C since
                             // the underlying decls respond to isCompleteDefinition(). Objective
                             // C decls don't respond to isCompleteDefinition() so we can't
                             // start the declaration definition right away. For C++ class/union/structs
                             // we want to start the definition in case the class is needed as the
                             // declaration context for a contained class or type without the need
                             // to complete that type..
 
                             if (class_language != eLanguageTypeObjC &&
                                 class_language != eLanguageTypeObjC_plus_plus)
                                 ClangASTContext::StartTagDeclarationDefinition (clang_type);
 
                             // Leave this as a forward declaration until we need
                             // to know the details of the type. lldb_private::Type
                             // will automatically call the SymbolFile virtual function
                             // "SymbolFileDWARF::CompleteType(Type *)"
                             // When the definition needs to be defined.
-                            assert(!dwarf->GetForwardDeclClangTypeToDie().count(ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) &&
+                            assert(!dwarf->GetForwardDeclClangTypeToDie().count(
+                                       ClangUtil::RemoveFastQualifiers(clang_type).GetOpaqueQualType()) &&
                                    "Type already in the forward declaration map!");
                             // Can't assume m_ast.GetSymbolFile() is actually a SymbolFileDWARF, it can be a
                             // SymbolFileDWARFDebugMap for Apple binaries.
                             //assert(((SymbolFileDWARF*)m_ast.GetSymbolFile())->UserIDMatches(die.GetDIERef().GetUID()) &&
                             //       "Adding incorrect type to forward declaration map");
                             dwarf->GetForwardDeclDieToClangType()[die.GetDIE()] = clang_type.GetOpaqueQualType();
-                            dwarf->GetForwardDeclClangTypeToDie()[ClangASTContext::RemoveFastQualifiers(clang_type).GetOpaqueQualType()] = die.GetDIERef();
+                            dwarf->GetForwardDeclClangTypeToDie()[ClangUtil::RemoveFastQualifiers(clang_type)
+                                                                      .GetOpaqueQualType()] = die.GetDIERef();
                             m_ast.SetHasExternalStorage (clang_type.GetOpaqueQualType(), true);
                         }
                     }
                 }
                     break;
 
                 case DW_TAG_enumeration_type:
                 {

                                                         {
                                                             for (auto method_iter = record_decl->method_begin();
                                                                  method_iter != record_decl->method_end();
                                                                  method_iter++)
                                                             {
                                                                 clang::CXXMethodDecl *method_decl = *method_iter;
                                                                 if (method_decl->getNameInfo().getAsString() == std::string(type_name_cstr))
                                                                 {
-                                                                    if (method_decl->getType() == ClangASTContext::GetQualType(clang_type))
+                                                                    if (method_decl->getType() ==
+                                                                        ClangUtil::GetQualType(clang_type))
                                                                     {
                                                                         add_method = false;
                                                                         LinkDeclContextToDIE(ClangASTContext::GetAsDeclContext(method_decl), die);
                                                                         type_handled = true;
 
                                                                         break;
                                                                     }
                                                                 }
switch (tag)
                         template_param_infos.names.push_back(NULL);
 
                     if (tag == DW_TAG_template_value_parameter &&
                         lldb_type != NULL &&
                         clang_type.IsIntegerType (is_signed) &&
                         uval64_valid)
                     {
                         llvm::APInt apint (lldb_type->GetByteSize() * 8, uval64, is_signed);
-                        template_param_infos.args.push_back (clang::TemplateArgument (*ast,
-                                                                                      llvm::APSInt(apint),
-                                                                                      ClangASTContext::GetQualType(clang_type)));
+                        template_param_infos.args.push_back(
+                            clang::TemplateArgument(*ast, llvm::APSInt(apint), ClangUtil::GetQualType(clang_type)));
                     }
                     else
                     {
-                        template_param_infos.args.push_back (clang::TemplateArgument (ClangASTContext::GetQualType(clang_type)));
+                        template_param_infos.args.push_back(
+                            clang::TemplateArgument(ClangUtil::GetQualType(clang_type)));
                     }
                 }
                 else
                 {
                     return false;
                 }
 
             }
for (DWARFDIE die = parent_die.GetFirstChild();
         }
     }
     if (template_param_infos.args.empty())
         return false;
     return template_param_infos.args.size() == template_param_infos.names.size();
 }
 
 bool
-DWARFASTParserClang::CanCompleteType (const lldb_private::CompilerType &compiler_type)
-{
-    if (m_clang_ast_importer_ap)
-        return ClangASTContext::CanImport(compiler_type, GetClangASTImporter());
-    else
-        return false;
-}
-
-bool
-DWARFASTParserClang::CompleteType (const lldb_private::CompilerType &compiler_type)
-{
-    if (CanCompleteType(compiler_type))
-    {
-        if (ClangASTContext::Import(compiler_type, GetClangASTImporter()))
-        {
-            ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
-            return true;
-        }
-        else
-        {
-            ClangASTContext::SetHasExternalStorage (compiler_type.GetOpaqueQualType(), false);
-        }
-    }
-    return false;
-}
-
-bool
-DWARFASTParserClang::CompleteTypeFromDWARF (const DWARFDIE &die,
-                                            lldb_private::Type *type,
-                                            CompilerType &clang_type)
+DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type, CompilerType &clang_type)
 {
     SymbolFileDWARF *dwarf = die.GetDWARF();
 
     lldb_private::Mutex::Locker locker(dwarf->GetObjectFile()->GetModule()->GetMutex());
 
     // Disable external storage for this type so we don't get anymore
     // clang::ExternalASTSource queries for this type.
     m_ast.SetHasExternalStorage (clang_type.GetOpaqueQualType(), false);
DWARFASTParserClang::CompleteTypeFromDWARF(const DWARFDIE &die, lldb_private::Type *type, CompilerType &clang_type)
     assert (clang_type);
     DWARFAttributes attributes;
     switch (tag)
     {
         case DW_TAG_structure_type:
         case DW_TAG_union_type:
         case DW_TAG_class_type:
         {
-            LayoutInfo layout_info;
+            ClangASTImporter::LayoutInfo layout_info;
 
             {
                 if (die.HasChildren())
                 {
                     LanguageType class_language = eLanguageTypeUnknown;
                     if (ClangASTContext::IsObjCObjectOrInterfaceType(clang_type))
                     {
                         class_language = eLanguageTypeObjC;
switch (tag)
                         }
                     }
 
                     // If we have a DW_TAG_structure_type instead of a DW_TAG_class_type we
                     // need to tell the clang type it is actually a class.
                     if (class_language != eLanguageTypeObjC)
                     {
                         if (is_a_class && tag_decl_kind != clang::TTK_Class)
-                            m_ast.SetTagTypeKind (ClangASTContext::GetQualType(clang_type), clang::TTK_Class);
+                            m_ast.SetTagTypeKind(ClangUtil::GetQualType(clang_type), clang::TTK_Class);
                     }
 
                     // Since DW_TAG_structure_type gets used for both classes
                     // and structures, we may need to set any DW_TAG_member
                     // fields to have a "private" access if none was specified.
                     // When we parsed the child members we tracked that actual
                     // accessibility value for each DW_TAG_member in the
                     // "member_accessibilities" array. If the value for the
switch (tag)
                                                           static_cast<void *>(clang_type.GetOpaqueQualType()), idx,
                                                           static_cast<uint32_t>(vbase_pos->second.getQuantity()),
                                                           vbase_pos->first->getNameAsString().c_str());
                                 }
                             }
 
                         }
                     }
-                    m_record_decl_to_layout_map.insert(std::make_pair(record_decl, layout_info));
+                    GetClangASTImporter().InsertRecordDecl(record_decl, layout_info);
                 }
             }
         }
 
             return (bool)clang_type;
 
         case DW_TAG_enumeration_type:
             ClangASTContext::StartTagDeclarationDefinition (clang_type);
if (die.GetDIENamesAndRanges (name,
                     return func_sp.get();
                 }
             }
         }
     }
     return NULL;
 }
 
-
 bool
-DWARFASTParserClang::ParseChildMembers (const SymbolContext& sc,
-                                        const DWARFDIE &parent_die,
-                                        CompilerType &class_clang_type,
-                                        const LanguageType class_language,
-                                        std::vector<clang::CXXBaseSpecifier *>& base_classes,
-                                        std::vector<int>& member_accessibilities,
-                                        DWARFDIECollection& member_function_dies,
-                                        DelayedPropertyList& delayed_properties,
-                                        AccessType& default_accessibility,
-                                        bool &is_a_class,
-                                        LayoutInfo &layout_info)
+DWARFASTParserClang::ParseChildMembers(const SymbolContext &sc, const DWARFDIE &parent_die,
+                                       CompilerType &class_clang_type, const LanguageType class_language,
+                                       std::vector<clang::CXXBaseSpecifier *> &base_classes,
+                                       std::vector<int> &member_accessibilities,
+                                       DWARFDIECollection &member_function_dies,
+                                       DelayedPropertyList &delayed_properties, AccessType &default_accessibility,
+                                       bool &is_a_class, ClangASTImporter::LayoutInfo &layout_info)
 {
     if (!parent_die)
         return 0;
 
     uint32_t member_idx = 0;
     BitfieldInfo last_field_info;
 
     ModuleSP module_sp = parent_die.GetDWARF()->GetObjectFile()->GetModule();
switch (die.Tag())
         case DW_TAG_variable:
         case DW_TAG_constant:
         case DW_TAG_formal_parameter:
         {
             SymbolFileDWARF *dwarf = die.GetDWARF();
             Type *type = GetTypeForDIE(die);
             const char *name = die.GetName();
             clang::DeclContext *decl_context = ClangASTContext::DeclContextGetAsDeclContext(dwarf->GetDeclContextContainingUID(die.GetID()));
-            decl = m_ast.CreateVariableDeclaration(
-                decl_context,
-                name,
-                ClangASTContext::GetQualType(type->GetForwardCompilerType()));
+            decl = m_ast.CreateVariableDeclaration(decl_context, name,
+                                                   ClangUtil::GetQualType(type->GetForwardCompilerType()));
             break;
         }
         case DW_TAG_imported_declaration:
         {
             SymbolFileDWARF *dwarf = die.GetDWARF();
             lldb::user_id_t imported_uid = die.GetAttributeValueAsReference(DW_AT_import, DW_INVALID_OFFSET);
 
             if (dwarf->UserIDMatches(imported_uid))
if (dst_size_artificial)
 
             failures.Append(dst_die);
         }
     }
 
     return (failures.Size() != 0);
 }
 
-
-bool
-DWARFASTParserClang::LayoutRecordType(const clang::RecordDecl *record_decl,
-                                      uint64_t &bit_size,
-                                      uint64_t &alignment,
-                                      llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
-                                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
-                                      llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
-{
-    RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find (record_decl);
-    bool success = false;
-    base_offsets.clear();
-    vbase_offsets.clear();
-    if (pos != m_record_decl_to_layout_map.end())
-    {
-        bit_size = pos->second.bit_size;
-        alignment = pos->second.alignment;
-        field_offsets.swap(pos->second.field_offsets);
-        base_offsets.swap (pos->second.base_offsets);
-        vbase_offsets.swap (pos->second.vbase_offsets);
-        m_record_decl_to_layout_map.erase(pos);
-        success = true;
-    }
-    else
-    {
-        bit_size = 0;
-        alignment = 0;
-        field_offsets.clear();
-    }
-    return success;
-}

lldb/trunk/source/Plugins/SymbolFile/DWARF/SymbolFileDWARF.cpp

 #include "lldb/Host/FileSystem.h"
 #include "lldb/Host/Host.h"
 
 #include "lldb/Interpreter/OptionValueFileSpecList.h"
 #include "lldb/Interpreter/OptionValueProperties.h"
 
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangUtil.h"
+#include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerDecl.h"
 #include "lldb/Symbol/CompilerDeclContext.h"
-#include "lldb/Symbol/CompileUnit.h"
-#include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/DebugMacros.h"
+#include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
+#include "lldb/Symbol/TypeMap.h"
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Symbol/VariableList.h"
-#include "lldb/Symbol/TypeMap.h"
 
 #include "Plugins/Language/CPlusPlus/CPlusPlusLanguage.h"
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
 
 #include "lldb/Target/Language.h"
 
 #include "lldb/Utility/TaskPool.h"
 
 #include "DWARFASTParser.h"
+#include "DWARFASTParserClang.h"
 #include "DWARFCompileUnit.h"
+#include "DWARFDIECollection.h"
 #include "DWARFDebugAbbrev.h"
 #include "DWARFDebugAranges.h"
 #include "DWARFDebugInfo.h"
 #include "DWARFDebugLine.h"
 #include "DWARFDebugMacro.h"
 #include "DWARFDebugPubnames.h"
 #include "DWARFDebugRanges.h"
 #include "DWARFDeclContext.h"
-#include "DWARFDIECollection.h"
 #include "DWARFFormValue.h"
 #include "LogChannelDWARF.h"
-#include "SymbolFileDWARFDwo.h"
 #include "SymbolFileDWARFDebugMap.h"
+#include "SymbolFileDWARFDwo.h"
 
 #include <map>
 
 #include <ctype.h>
 #include <string.h>
 
 //#define ENABLE_DEBUG_PRINTF // COMMENT OUT THIS LINE PRIOR TO CHECKIN
 

 }
 
 // This function is used when SymbolFileDWARFDebugMap owns a bunch of
 // SymbolFileDWARF objects to detect if this DWARF file is the one that
 // can resolve a compiler_type.
 bool
 SymbolFileDWARF::HasForwardDeclForClangType (const CompilerType &compiler_type)
 {
-    CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type);
+    CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type);
     if (GetForwardDeclClangTypeToDie().count (compiler_type_no_qualifiers.GetOpaqueQualType()))
     {
         return true;
     }
     TypeSystem *type_system = compiler_type.GetTypeSystem();
-    if (type_system)
-    {
-        DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
-        if (dwarf_ast)
-            return dwarf_ast->CanCompleteType(compiler_type);
-    }
+
+    ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(type_system);
+    if (!clang_type_system)
         return false;
+    DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
+    return ast_parser->GetClangASTImporter().CanImport(compiler_type);
 }
 
 
 bool
 SymbolFileDWARF::CompleteType (CompilerType &compiler_type)
 {
     lldb_private::Mutex::Locker locker(GetObjectFile()->GetModule()->GetMutex());
 
-    TypeSystem *type_system = compiler_type.GetTypeSystem();
-    if (type_system)
+    ClangASTContext *clang_type_system = llvm::dyn_cast_or_null<ClangASTContext>(compiler_type.GetTypeSystem());
+    if (clang_type_system)
     {
-        DWARFASTParser *dwarf_ast = type_system->GetDWARFParser();
-        if (dwarf_ast && dwarf_ast->CanCompleteType(compiler_type))
-            return dwarf_ast->CompleteType(compiler_type);
+        DWARFASTParserClang *ast_parser = static_cast<DWARFASTParserClang *>(clang_type_system->GetDWARFParser());
+        if (ast_parser && ast_parser->GetClangASTImporter().CanImport(compiler_type))
+            return ast_parser->GetClangASTImporter().CompleteType(compiler_type);
     }
 
     // We have a struct/union/class/enum that needs to be fully resolved.
-    CompilerType compiler_type_no_qualifiers = ClangASTContext::RemoveFastQualifiers(compiler_type);
+    CompilerType compiler_type_no_qualifiers = ClangUtil::RemoveFastQualifiers(compiler_type);
     auto die_it = GetForwardDeclClangTypeToDie().find (compiler_type_no_qualifiers.GetOpaqueQualType());
     if (die_it == GetForwardDeclClangTypeToDie().end())
     {
         // We have already resolved this type...
         return true;
     }
 
     DWARFDebugInfo* debug_info = DebugInfo();

lldb/trunk/source/Symbol/CMakeLists.txt

 add_lldb_library(lldbSymbol
   ArmUnwindInfo.cpp
   Block.cpp
   ClangASTContext.cpp
   ClangASTImporter.cpp
   ClangExternalASTSourceCallbacks.cpp
   ClangExternalASTSourceCommon.cpp
+  ClangUtil.cpp
   CompilerDecl.cpp
   CompilerDeclContext.cpp
   CompilerType.cpp
   CompileUnit.cpp
   CompactUnwindInfo.cpp
   DebugMacros.cpp
   Declaration.cpp
   DWARFCallFrameInfo.cpp

lldb/trunk/source/Symbol/ClangASTContext.cpp

 #undef NDEBUG
 #undef LLDB_DEFINED_NDEBUG_FOR_CLANG
 // Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
 #include <assert.h>
 #endif
 
 #include "llvm/Support/Signals.h"
 
+#include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
+#include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
+#include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Flags.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/RegularExpression.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
-#include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
-#include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
-#include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCallbacks.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/VerifyDecl.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Target/ObjCLanguageRuntime.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
if (ast)
                 
             case DW_ATE_lo_user:
                 // This has been seen to mean DW_AT_complex_integer
                 if (type_name)
                 {
                     if (::strstr(type_name, "complex"))
                     {
                         CompilerType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
-                        return CompilerType (ast, ast->getComplexType (GetQualType(complex_int_clang_type)));
+                        return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_int_clang_type)));
                     }
                 }
                 break;
                 
             case DW_ATE_complex_float:
                 if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
                     return CompilerType (ast, ast->FloatComplexTy);
                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
                     return CompilerType (ast, ast->DoubleComplexTy);
                 else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
                     return CompilerType (ast, ast->LongDoubleComplexTy);
                 else 
                 {
                     CompilerType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
-                    return CompilerType (ast, ast->getComplexType (GetQualType(complex_float_clang_type)));
+                    return CompilerType(ast, ast->getComplexType(ClangUtil::GetQualType(complex_float_clang_type)));
                 }
                 break;
                 
             case DW_ATE_float:
                 if (streq(type_name, "float") && QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
                     return CompilerType (ast, ast->FloatTy);
                 if (streq(type_name, "double") && QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
                     return CompilerType (ast, ast->DoubleTy);

 {
     ClangASTContext *ast = llvm::dyn_cast_or_null<ClangASTContext>(type1.GetTypeSystem());
     if (!ast || ast != type2.GetTypeSystem())
         return false;
 
     if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
         return true;
 
-    QualType type1_qual = GetQualType(type1);
-    QualType type2_qual = GetQualType(type2);
-    
+    QualType type1_qual = ClangUtil::GetQualType(type1);
+    QualType type2_qual = ClangUtil::GetQualType(type2);
     if (ignore_qualifiers)
     {
         type1_qual = type1_qual.getUnqualifiedType();
         type2_qual = type2_qual.getUnqualifiedType();
     }
     
     return ast->getASTContext()->hasSameType (type1_qual, type2_qual);
 }
if (decl_ctx == nullptr)
         decl_ctx = ast->getTranslationUnitDecl();
 
     
     const bool hasWrittenPrototype = true;
     const bool isConstexprSpecified = false;
 
     if (name && name[0])
     {
-        func_decl = FunctionDecl::Create (*ast,
-                                          decl_ctx,
-                                          SourceLocation(),
-                                          SourceLocation(),
-                                          DeclarationName (&ast->Idents.get(name)),
-                                          GetQualType(function_clang_type),
-                                          nullptr,
-                                          (clang::StorageClass)storage,
-                                          is_inline,
-                                          hasWrittenPrototype,
-                                          isConstexprSpecified);
+        func_decl = FunctionDecl::Create(
+            *ast, decl_ctx, SourceLocation(), SourceLocation(), DeclarationName(&ast->Idents.get(name)),
+            ClangUtil::GetQualType(function_clang_type), nullptr, (clang::StorageClass)storage, is_inline,
+            hasWrittenPrototype, isConstexprSpecified);
     }
     else
     {
-        func_decl = FunctionDecl::Create (*ast,
-                                          decl_ctx,
-                                          SourceLocation(),
-                                          SourceLocation(),
-                                          DeclarationName (),
-                                          GetQualType(function_clang_type),
-                                          nullptr,
-                                          (clang::StorageClass)storage,
-                                          is_inline,
-                                          hasWrittenPrototype,
-                                          isConstexprSpecified);
+        func_decl =
+            FunctionDecl::Create(*ast, decl_ctx, SourceLocation(), SourceLocation(), DeclarationName(),
+                                 ClangUtil::GetQualType(function_clang_type), nullptr, (clang::StorageClass)storage,
+                                 is_inline, hasWrittenPrototype, isConstexprSpecified);
     }
     if (func_decl)
         decl_ctx->addDecl (func_decl);
     
 #ifdef LLDB_CONFIGURATION_DEBUG
     VerifyDecl(func_decl);
 #endif
     
     return func_decl;
 }
 
 CompilerType
 ClangASTContext::CreateFunctionType (ASTContext *ast,
                                      const CompilerType& result_type,
                                      const CompilerType *args,
                                      unsigned num_args, 
                                      bool is_variadic, 
                                      unsigned type_quals)
 {
     assert (ast != nullptr);
     std::vector<QualType> qual_type_args;
     for (unsigned i=0; i<num_args; ++i)
-        qual_type_args.push_back (GetQualType(args[i]));
+        qual_type_args.push_back(ClangUtil::GetQualType(args[i]));
 
     // TODO: Detect calling convention in DWARF?
     FunctionProtoType::ExtProtoInfo proto_info;
     proto_info.Variadic = is_variadic;
     proto_info.ExceptionSpec = EST_None;
     proto_info.TypeQuals = type_quals;
     proto_info.RefQualifier = RQ_None;
 
-    return CompilerType (ast, ast->getFunctionType (GetQualType(result_type),
-                                                    qual_type_args,
-                                                    proto_info));
+    return CompilerType(ast, ast->getFunctionType(ClangUtil::GetQualType(result_type), qual_type_args, proto_info));
 }
 
 ParmVarDecl *
 ClangASTContext::CreateParameterDeclaration (const char *name, const CompilerType &param_type, int storage)
 {
     ASTContext *ast = getASTContext();
     assert (ast != nullptr);
-    return ParmVarDecl::Create(*ast,
-                                ast->getTranslationUnitDecl(),
-                                SourceLocation(),
-                                SourceLocation(),
-                                name && name[0] ? &ast->Idents.get(name) : nullptr,
-                                GetQualType(param_type),
-                                nullptr,
-                                (clang::StorageClass)storage,
-                                nullptr);
+    return ParmVarDecl::Create(*ast, ast->getTranslationUnitDecl(), SourceLocation(), SourceLocation(),
+                               name && name[0] ? &ast->Idents.get(name) : nullptr, ClangUtil::GetQualType(param_type),
+                               nullptr, (clang::StorageClass)storage, nullptr);
 }
 
 void
 ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
 {
     if (function_decl)
         function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params));
 }
 
 
 #pragma mark Array Types
 
 CompilerType
 ClangASTContext::CreateArrayType (const CompilerType &element_type,
                                   size_t element_count,
                                   bool is_vector)
 {
     if (element_type.IsValid())
     {
         ASTContext *ast = getASTContext();
         assert (ast != nullptr);
 
         if (is_vector)
         {
-            return CompilerType (ast, ast->getExtVectorType(GetQualType(element_type), element_count));
+            return CompilerType(ast, ast->getExtVectorType(ClangUtil::GetQualType(element_type), element_count));
         }
         else
         {
         
             llvm::APInt ap_element_count (64, element_count);
             if (element_count == 0)
             {
-                return CompilerType (ast, ast->getIncompleteArrayType (GetQualType(element_type),
-                                                                       clang::ArrayType::Normal,
-                                                                       0));
+                return CompilerType(ast, ast->getIncompleteArrayType(ClangUtil::GetQualType(element_type),
+                                                                     clang::ArrayType::Normal, 0));
             }
             else
             {
-                return CompilerType (ast, ast->getConstantArrayType (GetQualType(element_type),
-                                                                     ap_element_count,
-                                                                     clang::ArrayType::Normal,
-                                                                     0));
+                return CompilerType(ast, ast->getConstantArrayType(ClangUtil::GetQualType(element_type),
+                                                                   ap_element_count, clang::ArrayType::Normal, 0));
             }
         }
     }
     return CompilerType();
 }
 
 CompilerType
 ClangASTContext::GetOrCreateStructForIdentifier (const ConstString &type_name,
EnumDecl *enum_decl = EnumDecl::Create (*ast,
                                             false,  // IsScoped
                                             false,  // IsScopedUsingClassTag
                                             false); // IsFixed
     
     
     if (enum_decl)
     {
         // TODO: check if we should be setting the promotion type too?
-        enum_decl->setIntegerType(GetQualType(integer_clang_type));
-        
+        enum_decl->setIntegerType(ClangUtil::GetQualType(integer_clang_type));
         enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
         
         return CompilerType (ast, ast->getTagDeclType(enum_decl));
     }
     return CompilerType();
 }
 
 // Disable this for now since I can't seem to get a nicely formatted float
if (record_decl)
         return true;
     }
     return false;
 }
 
 clang::DeclContext *
 ClangASTContext::GetDeclContextForType (const CompilerType& type)
 {
-    return GetDeclContextForType(GetQualType(type));
+    return GetDeclContextForType(ClangUtil::GetQualType(type));
 }
 
 clang::DeclContext *
 ClangASTContext::GetDeclContextForType (clang::QualType type)
 {
     if (type.isNull())
         return nullptr;
     
ClangASTContext::IsDefined(lldb::opaque_compiler_type_t type)
     return true;
 }
 
 bool
 ClangASTContext::IsObjCClassType (const CompilerType& type)
 {
     if (type)
     {
-        clang::QualType qual_type (GetCanonicalQualType(type));
-        
+        clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
         const clang::ObjCObjectPointerType *obj_pointer_type = llvm::dyn_cast<clang::ObjCObjectPointerType>(qual_type);
         
         if (obj_pointer_type)
             return obj_pointer_type->isObjCClassType();
     }
     return false;
 }
 
 bool
 ClangASTContext::IsObjCObjectOrInterfaceType (const CompilerType& type)
 {
-    if (IsClangType(type))
-        return GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
+    if (ClangUtil::IsClangType(type))
+        return ClangUtil::GetCanonicalQualType(type)->isObjCObjectOrInterfaceType();
     return false;
 }
 
 bool
 ClangASTContext::IsPolymorphicClass (lldb::opaque_compiler_type_t type)
 {
     if (type)
     {
ClangASTContext::SupportsLanguage (lldb::LanguageType language)
     return ClangASTContextSupportsLanguage(language);
 }
 
 bool
 ClangASTContext::GetCXXClassName (const CompilerType& type, std::string &class_name)
 {
     if (type)
     {
-        clang::QualType qual_type (GetCanonicalQualType(type));
+        clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
         if (!qual_type.isNull())
         {
             clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
             if (cxx_record_decl)
             {
                 class_name.assign(cxx_record_decl->getIdentifier()->getNameStart());
                 return true;
             }
         }
     }
     class_name.clear();
     return false;
 }
 
 
 bool
 ClangASTContext::IsCXXClassType (const CompilerType& type)
 {
     if (!type)
         return false;
-    
-    clang::QualType qual_type (GetCanonicalQualType(type));
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
     if (!qual_type.isNull() && qual_type->getAsCXXRecordDecl() != nullptr)
         return true;
     return false;
 }
 
 bool
 ClangASTContext::IsBeingDefined (lldb::opaque_compiler_type_t type)
 {
     if (!type)
         return false;
     clang::QualType qual_type (GetCanonicalQualType(type));
     const clang::TagType *tag_type = llvm::dyn_cast<clang::TagType>(qual_type);
     if (tag_type)
         return tag_type->isBeingDefined();
     return false;
 }
 
 bool
 ClangASTContext::IsObjCObjectPointerType (const CompilerType& type, CompilerType *class_type_ptr)
 {
     if (!type)
         return false;
 
-    clang::QualType qual_type (GetCanonicalQualType(type));
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
 
     if (!qual_type.isNull() && qual_type->isObjCObjectPointerType())
     {
         if (class_type_ptr)
         {
             if (!qual_type->isObjCClassType() &&
                 !qual_type->isObjCIdType())
             {
ClangASTContext::IsObjCObjectPointerType (const CompilerType& type, CompilerType *class_type_ptr)
     return false;
 }
 
 bool
 ClangASTContext::GetObjCClassName (const CompilerType& type, std::string &class_name)
 {
     if (!type)
         return false;
-    
-    clang::QualType qual_type (GetCanonicalQualType(type));
-    
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
     const clang::ObjCObjectType *object_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
     if (object_type)
     {
         const clang::ObjCInterfaceDecl *interface = object_type->getInterface();
         if (interface)
         {
             class_name = interface->getNameAsString();
             return true;
ClangASTContext::CreateTypedefType (const CompilerType& type,
                                     const CompilerDeclContext &compiler_decl_ctx)
 {
     if (type && typedef_name && typedef_name[0])
     {
         ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
         if (!ast)
             return CompilerType();
         clang::ASTContext* clang_ast = ast->getASTContext();
-        clang::QualType qual_type (GetQualType(type));
+        clang::QualType qual_type(ClangUtil::GetQualType(type));
 
         clang::DeclContext *decl_ctx = ClangASTContext::DeclContextGetAsDeclContext(compiler_decl_ctx);
         if (decl_ctx == nullptr)
             decl_ctx = ast->getASTContext()->getTranslationUnitDecl();
 
         clang::TypedefDecl *decl = clang::TypedefDecl::Create (*clang_ast,
                                                                decl_ctx,
                                                                clang::SourceLocation(),
ClangASTContext::GetTypedefedType (lldb::opaque_compiler_type_t type)
     {
         const clang::TypedefType *typedef_type = llvm::dyn_cast<clang::TypedefType>(GetQualType(type));
         if (typedef_type)
             return CompilerType (getASTContext(), typedef_type->getDecl()->getUnderlyingType());
     }
     return CompilerType();
 }
 
-CompilerType
-ClangASTContext::RemoveFastQualifiers (const CompilerType& type)
-{
-    if (IsClangType(type))
-    {
-        clang::QualType qual_type(GetQualType(type));
-        qual_type.getQualifiers().removeFastQualifiers();
-        return CompilerType (type.GetTypeSystem(), qual_type.getAsOpaquePtr());
-    }
-    return type;
-}
-
 
 //----------------------------------------------------------------------
 // Create related types using the current type's AST
 //----------------------------------------------------------------------
 
 CompilerType
 ClangASTContext::GetBasicTypeFromAST (lldb::BasicType basic_type)
 {
ClangASTContext::GetTemplateArgument (lldb::opaque_compiler_type_t type, size_t arg_idx, lldb::TemplateArgumentKind &kind)
     kind = eTemplateArgumentKindNull;
     return CompilerType ();
 }
 
 CompilerType
 ClangASTContext::GetTypeForFormatters (void* type)
 {
     if (type)
-        return RemoveFastQualifiers(CompilerType(this, type));
+        return ClangUtil::RemoveFastQualifiers(CompilerType(this, type));
     return CompilerType();
 }
 
 static bool
 IsOperator (const char *name, clang::OverloadedOperatorKind &op_kind)
 {
     if (name == nullptr || name[0] == '\0')
         return false;
#undef OPERATOR_PREFIX_LENGTH
     }
     
     return true;
 }
 
 clang::EnumDecl *
 ClangASTContext::GetAsEnumDecl (const CompilerType& type)
 {
-    const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(GetCanonicalQualType(type));
+    const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(ClangUtil::GetCanonicalQualType(type));
     if (enutype)
         return enutype->getDecl();
     return NULL;
 }
 
 clang::RecordDecl *
 ClangASTContext::GetAsRecordDecl (const CompilerType& type)
 {
-    const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(GetCanonicalQualType(type));
+    const clang::RecordType *record_type = llvm::dyn_cast<clang::RecordType>(ClangUtil::GetCanonicalQualType(type));
     if (record_type)
         return record_type->getDecl();
     return nullptr;
 }
 
 clang::TagDecl *
 ClangASTContext::GetAsTagDecl (const CompilerType& type)
 {
-    clang::QualType qual_type = GetCanonicalQualType(type);
+    clang::QualType qual_type = ClangUtil::GetCanonicalQualType(type);
     if (qual_type.isNull())
         return nullptr;
     else
         return qual_type->getAsTagDecl();
 }
 
 clang::CXXRecordDecl *
 ClangASTContext::GetAsCXXRecordDecl (lldb::opaque_compiler_type_t type)
 {
     return GetCanonicalQualType(type)->getAsCXXRecordDecl();
 }
 
 clang::ObjCInterfaceDecl *
 ClangASTContext::GetAsObjCInterfaceDecl (const CompilerType& type)
 {
-    const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(GetCanonicalQualType(type));
+    const clang::ObjCObjectType *objc_class_type =
+        llvm::dyn_cast<clang::ObjCObjectType>(ClangUtil::GetCanonicalQualType(type));
     if (objc_class_type)
         return objc_class_type->getInterface();
     return nullptr;
 }
 
 clang::FieldDecl *
 ClangASTContext::AddFieldToRecordType (const CompilerType& type, const char *name,
                                        const CompilerType &field_clang_type,
ClangASTContext::AddFieldToRecordType (const CompilerType& type, const char *name,
     {
         llvm::APInt bitfield_bit_size_apint(clang_ast->getTypeSize(clang_ast->IntTy), bitfield_bit_size);
         bit_width = new (*clang_ast)clang::IntegerLiteral (*clang_ast, bitfield_bit_size_apint, clang_ast->IntTy, clang::SourceLocation());
     }
     
     clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type);
     if (record_decl)
     {
-        field = clang::FieldDecl::Create (*clang_ast,
-                                          record_decl,
-                                          clang::SourceLocation(),
-                                          clang::SourceLocation(),
-                                          name ? &clang_ast->Idents.get(name) : nullptr,  // Identifier
-                                          GetQualType(field_clang_type),             // Field type
-                                          nullptr,                                    // TInfo *
-                                          bit_width,                                  // BitWidth
-                                          false,                                      // Mutable
-                                          clang::ICIS_NoInit);                        // HasInit
-        
+        field = clang::FieldDecl::Create(*clang_ast, record_decl, clang::SourceLocation(), clang::SourceLocation(),
+                                         name ? &clang_ast->Idents.get(name) : nullptr, // Identifier
+                                         ClangUtil::GetQualType(field_clang_type),      // Field type
+                                         nullptr,                                       // TInfo *
+                                         bit_width,                                     // BitWidth
+                                         false,                                         // Mutable
+                                         clang::ICIS_NoInit);                           // HasInit
         if (!name)
         {
             // Determine whether this field corresponds to an anonymous
             // struct or union.
             if (const clang::TagType *TagT = field->getType()->getAs<clang::TagType>()) {
                 if (clang::RecordDecl *Rec = llvm::dyn_cast<clang::RecordDecl>(TagT->getDecl()))
                     if (!Rec->getDeclName()) {
                         Rec->setAnonymousStructOrUnion(true);
#endif
     {
         clang::ObjCInterfaceDecl *class_interface_decl = ast->GetAsObjCInterfaceDecl (type);
         
         if (class_interface_decl)
         {
             const bool is_synthesized = false;
             
             field_clang_type.GetCompleteType();
-            
-            field = clang::ObjCIvarDecl::Create (*clang_ast,
-                                                 class_interface_decl,
-                                                 clang::SourceLocation(),
-                                                 clang::SourceLocation(),
-                                                 name ? &clang_ast->Idents.get(name) : nullptr,   // Identifier
-                                                 GetQualType(field_clang_type),           // Field type
-                                                 nullptr,                                     // TypeSourceInfo *
-                                                 ConvertAccessTypeToObjCIvarAccessControl (access),
-                                                 bit_width,
-                                                 is_synthesized);
-            
+            field = clang::ObjCIvarDecl::Create(
+                *clang_ast, class_interface_decl, clang::SourceLocation(), clang::SourceLocation(),
+                name ? &clang_ast->Idents.get(name) : nullptr, // Identifier
+                ClangUtil::GetQualType(field_clang_type),      // Field type
+                nullptr,                                       // TypeSourceInfo *
+                ConvertAccessTypeToObjCIvarAccessControl(access), bit_width, is_synthesized);
             if (field)
             {
                 class_interface_decl->addDecl(field);
                 
 #ifdef LLDB_CONFIGURATION_DEBUG
                 VerifyDecl(field);
 #endif
             }
if (!type.IsValid() || !var_type.IsValid())
         return nullptr;
     ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
     if (!ast)
         return nullptr;
     
     clang::RecordDecl *record_decl = ast->GetAsRecordDecl (type);
     if (record_decl)
     {
-        var_decl = clang::VarDecl::Create (*ast->getASTContext(),                      // ASTContext &
-                                           record_decl,                                // DeclContext *
-                                           clang::SourceLocation(),                    // clang::SourceLocation StartLoc
-                                           clang::SourceLocation(),                    // clang::SourceLocation IdLoc
-                                           name ? &ast->getASTContext()->Idents.get(name) : nullptr,  // clang::IdentifierInfo *
-                                           GetQualType(var_type),                      // Variable clang::QualType
-                                           nullptr,                                    // TypeSourceInfo *
-                                           clang::SC_Static);                          // StorageClass
+        var_decl =
+            clang::VarDecl::Create(*ast->getASTContext(),   // ASTContext &
+                                   record_decl,             // DeclContext *
+                                   clang::SourceLocation(), // clang::SourceLocation StartLoc
+                                   clang::SourceLocation(), // clang::SourceLocation IdLoc
+                                   name ? &ast->getASTContext()->Idents.get(name) : nullptr, // clang::IdentifierInfo *
+                                   ClangUtil::GetQualType(var_type),                         // Variable clang::QualType
+                                   nullptr,                                                  // TypeSourceInfo *
+                                   clang::SC_Static);                                        // StorageClass
         if (var_decl)
         {
             var_decl->setAccess(ClangASTContext::ConvertAccessTypeToAccessSpecifier (access));
             record_decl->addDecl(var_decl);
             
 #ifdef LLDB_CONFIGURATION_DEBUG
             VerifyDecl(var_decl);
 #endif
if (!type || !method_clang_type.IsValid() || name == nullptr || name[0] == '\0')
         return nullptr;
     
     clang::QualType record_qual_type(GetCanonicalQualType(type));
     
     clang::CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
     
     if (cxx_record_decl == nullptr)
         return nullptr;
-    
-    clang::QualType method_qual_type (GetQualType(method_clang_type));
-    
+    clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
     clang::CXXMethodDecl *cxx_method_decl = nullptr;
     
     clang::DeclarationName decl_name (&getASTContext()->Idents.get(name));
     
     const clang::FunctionType *function_type = llvm::dyn_cast<clang::FunctionType>(method_qual_type.getTypePtr());
     
     if (function_type == nullptr)
         return nullptr;
if (class_interface_decl)
             property_clang_type_to_access = CompilerType (clang_ast, ivar_decl->getType());
         
         if (class_interface_decl && property_clang_type_to_access.IsValid())
         {
             clang::TypeSourceInfo *prop_type_source;
             if (ivar_decl)
                 prop_type_source = clang_ast->getTrivialTypeSourceInfo (ivar_decl->getType());
             else
-                prop_type_source = clang_ast->getTrivialTypeSourceInfo (GetQualType(property_clang_type));
-            
-            clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create (*clang_ast,
-                                                                                      class_interface_decl,
-                                                                                      clang::SourceLocation(), // Source Location
-                                                                                      &clang_ast->Idents.get(property_name),
-                                                                                      clang::SourceLocation(), //Source Location for AT
-                                                                                      clang::SourceLocation(), //Source location for (
-                                                                                      ivar_decl ? ivar_decl->getType() : ClangASTContext::GetQualType(property_clang_type),
-                                                                                      prop_type_source);
-            
+                prop_type_source = clang_ast->getTrivialTypeSourceInfo(ClangUtil::GetQualType(property_clang_type));
+            clang::ObjCPropertyDecl *property_decl = clang::ObjCPropertyDecl::Create(
+                *clang_ast, class_interface_decl,
+                clang::SourceLocation(), // Source Location for AT
+                clang::SourceLocation(), // Source location for (
+                ivar_decl ? ivar_decl->getType() : ClangUtil::GetQualType(property_clang_type), prop_type_source);
             if (property_decl)
             {
                 if (metadata)
                     ClangASTContext::SetMetadata(clang_ast, property_decl, *metadata);
                 
                 class_interface_decl->addDecl (property_decl);
                 
                 clang::Selector setter_sel, getter_sel;
if (class_interface_decl)
                 {
                     const bool isInstance = true;
                     const bool isVariadic = false;
                     const bool isSynthesized = false;
                     const bool isImplicitlyDeclared = true;
                     const bool isDefined = false;
                     const clang::ObjCMethodDecl::ImplementationControl impControl = clang::ObjCMethodDecl::None;
                     const bool HasRelatedResultType = false;
-                    
-                    clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create (*clang_ast,
-                                                                                   clang::SourceLocation(),
-                                                                                   clang::SourceLocation(),
-                                                                                   getter_sel,
-                                                                                   GetQualType(property_clang_type_to_access),
-                                                                                   nullptr,
-                                                                                   class_interface_decl,
-                                                                                   isInstance,
-                                                                                   isVariadic,
-                                                                                   isSynthesized,
-                                                                                   isImplicitlyDeclared,
-                                                                                   isDefined,
-                                                                                   impControl,
-                                                                                   HasRelatedResultType);
-                    
+                    clang::ObjCMethodDecl *getter = clang::ObjCMethodDecl::Create(
+                        *clang_ast, clang::SourceLocation(), clang::SourceLocation(), getter_sel,
+                        ClangUtil::GetQualType(property_clang_type_to_access), nullptr, class_interface_decl,
+                        isInstance, isVariadic, isSynthesized, isImplicitlyDeclared, isDefined, impControl,
                     if (getter && metadata)
                         ClangASTContext::SetMetadata(clang_ast, getter, *metadata);
                     
                     if (getter)
                     {
                         getter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(), llvm::ArrayRef<clang::SourceLocation>());
                         
                         class_interface_decl->addDecl(getter);
if (class_interface_decl)
                                                                                    isDefined,
                                                                                    impControl,
                                                                                    HasRelatedResultType);
                     
                     if (setter && metadata)
                         ClangASTContext::SetMetadata(clang_ast, setter, *metadata);
                     
                     llvm::SmallVector<clang::ParmVarDecl *, 1> params;
-                    
-                    params.push_back (clang::ParmVarDecl::Create (*clang_ast,
-                                                                  setter,
-                                                                  clang::SourceLocation(),
-                                                                  clang::SourceLocation(),
-                                                                  nullptr, // anonymous
-                                                                  GetQualType(property_clang_type_to_access),
-                                                                  nullptr,
-                                                                  clang::SC_Auto,
-                                                                  nullptr));
-                    
+                    params.push_back(clang::ParmVarDecl::Create(
+                        *clang_ast, setter, clang::SourceLocation(), clang::SourceLocation(),
+                        ClangUtil::GetQualType(property_clang_type_to_access), nullptr, clang::SC_Auto, nullptr));
                     if (setter)
                     {
                         setter->setMethodParams(*clang_ast, llvm::ArrayRef<clang::ParmVarDecl*>(params), llvm::ArrayRef<clang::SourceLocation>());
                         
                         class_interface_decl->addDecl(setter);
                     }
                 }
                 
ClangASTContext::AddMethodToObjCObjectType (const CompilerType& type,
     }
     
     
     if (selector_idents.size() == 0)
         return nullptr;
     
     clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
                                                                     selector_idents.data());
-    
-    clang::QualType method_qual_type (GetQualType(method_clang_type));
-    
+    clang::QualType method_qual_type(ClangUtil::GetQualType(method_clang_type));
     // Populate the method decl with parameter decls
     const clang::Type *method_type(method_qual_type.getTypePtr());
     
     if (method_type == nullptr)
         return nullptr;
     
     const clang::FunctionProtoType *method_function_prototype (llvm::dyn_cast<clang::FunctionProtoType>(method_type));
     
     if (!method_function_prototype)
         return nullptr;
     
     
     bool is_variadic = false;
     bool is_synthesized = false;
     bool is_defined = false;
     clang::ObjCMethodDecl::ImplementationControl imp_control = clang::ObjCMethodDecl::None;
     
     const unsigned num_args = method_function_prototype->getNumParams();
     
     if (num_args != num_selectors_with_args)
         return nullptr; // some debug information is corrupt.  We are not going to deal with it.
-    
-    clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create (*ast,
-                                                                             clang::SourceLocation(), // beginLoc,
-                                                                             clang::SourceLocation(), // endLoc,
-                                                                             method_selector,
-                                                                             method_function_prototype->getReturnType(),
-                                                                             nullptr, // TypeSourceInfo *ResultTInfo,
-                                                                             ClangASTContext::GetASTContext(ast)->GetDeclContextForType(GetQualType(type)),
-                                                                             name[0] == '-',
-                                                                             is_variadic,
-                                                                             is_synthesized,
-                                                                             true, // is_implicitly_declared; we force this to true because we don't have source locations
-                                                                             is_defined,
-                                                                             imp_control,
-                                                                             false /*has_related_result_type*/);
-    
-    
+    clang::ObjCMethodDecl *objc_method_decl = clang::ObjCMethodDecl::Create(
+        *ast,
+        method_selector, method_function_prototype->getReturnType(),
+        ClangASTContext::GetASTContext(ast)->GetDeclContextForType(ClangUtil::GetQualType(type)), name[0] == '-',
+        is_variadic, is_synthesized,
+        is_defined, imp_control, false /*has_related_result_type*/);
     if (objc_method_decl == nullptr)
         return nullptr;
     
     if (num_args > 0)
     {
         llvm::SmallVector<clang::ParmVarDecl *, 12> params;
         
         for (unsigned param_index = 0; param_index < num_args; ++param_index)

 #endif
     
     return objc_method_decl;
 }
 
 bool
 ClangASTContext::GetHasExternalStorage (const CompilerType &type)
 {
-    if (IsClangType(type))
+    if (ClangUtil::IsClangType(type))
         return false;
 
-    clang::QualType qual_type (GetCanonicalQualType(type));
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(type));
 
     const clang::Type::TypeClass type_class = qual_type->getTypeClass();
     switch (type_class)
     {
         case clang::Type::Record:
         {
             clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
             if (cxx_record_decl)
switch (type_class)
             
         default:
             break;
     }
     return false;
 }
 
 
-bool
-ClangASTContext::CanImport (const CompilerType &type, lldb_private::ClangASTImporter &importer)
-{
-    if (IsClangType(type))
-    {
-        // TODO: remove external completion BOOL
-        // CompleteAndFetchChildren should get the Decl out and check for the
-
-        clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
-
-        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
-        switch (type_class)
-        {
-            case clang::Type::Record:
-            {
-                const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
-                if (cxx_record_decl)
-                {
-                    if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL))
-                        return true;
-                }
-            }
-                break;
-
-            case clang::Type::Enum:
-            {
-                clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
-                if (enum_decl)
-                {
-                    if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL))
-                        return true;
-                }
-            }
-                break;
-
-            case clang::Type::ObjCObject:
-            case clang::Type::ObjCInterface:
-            {
-                const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
-                if (objc_class_type)
-                {
-                    clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
-                    // We currently can't complete objective C types through the newly added ASTContext
-                    // because it only supports TagDecl objects right now...
-                    if (class_interface_decl)
-                    {
-                        if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL))
-                            return true;
-                    }
-                }
-            }
-                break;
-
-
-            case clang::Type::Typedef:
-                return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer);
-
-            case clang::Type::Auto:
-                return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()), importer);
-                
-            case clang::Type::Elaborated:
-                return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()), importer);
-
-            case clang::Type::Paren:
-                return CanImport(CompilerType (type.GetTypeSystem(), llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()), importer);
-
-            default:
-                break;
-        }
-    }
-    return false;
-}
-bool
-ClangASTContext::Import (const CompilerType &type, lldb_private::ClangASTImporter &importer)
-{
-    if (IsClangType(type))
-    {
-        // TODO: remove external completion BOOL
-        // CompleteAndFetchChildren should get the Decl out and check for the
-
-        clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
-
-        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
-        switch (type_class)
-        {
-            case clang::Type::Record:
-            {
-                const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
-                if (cxx_record_decl)
-                {
-                    if (importer.ResolveDeclOrigin (cxx_record_decl, NULL, NULL))
-                        return importer.CompleteAndFetchChildren(qual_type);
-                }
-            }
-                break;
-
-            case clang::Type::Enum:
-            {
-                clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
-                if (enum_decl)
-                {
-                    if (importer.ResolveDeclOrigin (enum_decl, NULL, NULL))
-                        return importer.CompleteAndFetchChildren(qual_type);
-                }
-            }
-                break;
-
-            case clang::Type::ObjCObject:
-            case clang::Type::ObjCInterface:
-            {
-                const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
-                if (objc_class_type)
-                {
-                    clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
-                    // We currently can't complete objective C types through the newly added ASTContext
-                    // because it only supports TagDecl objects right now...
-                    if (class_interface_decl)
-                    {
-                        if (importer.ResolveDeclOrigin (class_interface_decl, NULL, NULL))
-                            return importer.CompleteAndFetchChildren(qual_type);
-                    }
-                }
-            }
-                break;
-
-
-            case clang::Type::Typedef:
-                return Import (CompilerType(type.GetTypeSystem(), llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()), importer);
-
-            case clang::Type::Auto:
-                return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()), importer);
-                
-            case clang::Type::Elaborated:
-                return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()), importer);
-
-            case clang::Type::Paren:
-                return Import (CompilerType(type.GetTypeSystem(),llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()), importer);
-                
-            default:
-                break;
-        }
-    }
-    return false;
-}
-
-
 #pragma mark TagDecl
 
 bool
 ClangASTContext::StartTagDeclarationDefinition (const CompilerType &type)
 {
-    clang::QualType qual_type (ClangASTContext::GetQualType(type));
+    clang::QualType qual_type(ClangUtil::GetQualType(type));
     if (!qual_type.isNull())
     {
         const clang::TagType *tag_type = qual_type->getAs<clang::TagType>();
         if (tag_type)
         {
             clang::TagDecl *tag_decl = tag_type->getDecl();
             if (tag_decl)
             {
if (!qual_type.isNull())
         }
     }
     return false;
 }
 
 bool
 ClangASTContext::CompleteTagDeclarationDefinition (const CompilerType& type)
 {
-    clang::QualType qual_type (ClangASTContext::GetQualType(type));
+    clang::QualType qual_type(ClangUtil::GetQualType(type));
     if (!qual_type.isNull())
     {
         clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
         
         if (cxx_record_decl)
         {
             if (!cxx_record_decl->isCompleteDefinition())
                 cxx_record_decl->completeDefinition();
if (type && enumerator_clang_type.IsValid() && name && name[0])
         if (clang_type)
         {
             const clang::EnumType *enutype = llvm::dyn_cast<clang::EnumType>(clang_type);
             
             if (enutype)
             {
                 llvm::APSInt enum_llvm_apsint(enum_value_bit_size, is_signed);
                 enum_llvm_apsint = enum_value;
-                clang::EnumConstantDecl *enumerator_decl =
-                clang::EnumConstantDecl::Create (*getASTContext(),
-                                                 enutype->getDecl(),
-                                                 clang::SourceLocation(),
-                                                 name ? &getASTContext()->Idents.get(name) : nullptr,    // Identifier
-                                                 GetQualType(enumerator_clang_type),
-                                                 nullptr,
-                                                 enum_llvm_apsint);
-                
+                clang::EnumConstantDecl *enumerator_decl = clang::EnumConstantDecl::Create(
+                    *getASTContext(), enutype->getDecl(), clang::SourceLocation(),
+                    name ? &getASTContext()->Idents.get(name) : nullptr, // Identifier
+                    ClangUtil::GetQualType(enumerator_clang_type), nullptr, enum_llvm_apsint);
                 if (enumerator_decl)
                 {
                     enutype->getDecl()->addDecl(enumerator_decl);
                     
 #ifdef LLDB_CONFIGURATION_DEBUG
                     VerifyDecl(enumerator_decl);
 #endif
                     

 CompilerType
 ClangASTContext::CreateMemberPointerType (const CompilerType& type, const CompilerType &pointee_type)
 {
     if (type && pointee_type.IsValid() && type.GetTypeSystem() == pointee_type.GetTypeSystem())
     {
         ClangASTContext *ast = llvm::dyn_cast<ClangASTContext>(type.GetTypeSystem());
         if (!ast)
             return CompilerType();
-        return CompilerType (ast->getASTContext(),
-                             ast->getASTContext()->getMemberPointerType (GetQualType(pointee_type),
-                                                                         GetQualType(type).getTypePtr()));
+        return CompilerType(ast->getASTContext(),
+                            ast->getASTContext()->getMemberPointerType(ClangUtil::GetQualType(pointee_type),
+                                                                       ClangUtil::GetQualType(type).getTypePtr()));
     }
     return CompilerType();
 }
 
 
 size_t
 ClangASTContext::ConvertStringToFloatValue (lldb::opaque_compiler_type_t type, const char *s, uint8_t *dst, size_t dst_size)
 {
if (type)
             s->Write (buf.data(), buf.size());
         }
     }
 }
 
 void
 ClangASTContext::DumpTypeName (const CompilerType &type)
 {
-    if (IsClangType(type))
+    if (ClangUtil::IsClangType(type))
     {
-        clang::QualType qual_type(GetCanonicalQualType(RemoveFastQualifiers(type)));
+        clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
 
         const clang::Type::TypeClass type_class = qual_type->getTypeClass();
         switch (type_class)
         {
             case clang::Type::Record:
             {
                 const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
                 if (cxx_record_decl)
ClangASTContext::CompleteObjCInterfaceDecl (void *baton, clang::ObjCInterfaceDecl *decl)
     if (sym_file)
     {
         CompilerType clang_type = GetTypeForDecl (decl);
         if (clang_type)
             sym_file->CompleteType (clang_type);
     }
 }
 
-
 DWARFASTParser *
-ClangASTContext::GetDWARFParser ()
+ClangASTContext::GetDWARFParser()
 {
     if (!m_dwarf_ast_parser_ap)
         m_dwarf_ast_parser_ap.reset(new DWARFASTParserClang(*this));
     return m_dwarf_ast_parser_ap.get();
 }
 
 
 bool
 ClangASTContext::LayoutRecordType(void *baton,
                                   const clang::RecordDecl *record_decl,
                                   uint64_t &bit_size,
                                   uint64_t &alignment,
                                   llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
 {
     ClangASTContext *ast = (ClangASTContext *)baton;
     DWARFASTParserClang *dwarf_ast_parser = (DWARFASTParserClang *)ast->GetDWARFParser();
-    return dwarf_ast_parser->LayoutRecordType(record_decl, bit_size, alignment, field_offsets, base_offsets, vbase_offsets);
+    return dwarf_ast_parser->GetClangASTImporter().LayoutRecordType(record_decl, bit_size, alignment, field_offsets,
+                                                                    base_offsets, vbase_offsets);
 }
 
 //----------------------------------------------------------------------
 // CompilerDecl override functions
 //----------------------------------------------------------------------
 lldb::VariableSP
 ClangASTContext::DeclGetVariable (void *opaque_decl)
 {

lldb/trunk/source/Symbol/ClangASTImporter.cpp

 //===-- ClangASTImporter.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
-#include "clang/AST/Decl.h"
-#include "clang/AST/DeclCXX.h"
-#include "clang/AST/DeclObjC.h"
-#include "llvm/Support/raw_ostream.h"
+#include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Symbol/ClangASTImporter.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
+#include "lldb/Symbol/ClangUtil.h"
 #include "lldb/Utility/LLDBAssert.h"
+#include "clang/AST/Decl.h"
+#include "clang/AST/DeclCXX.h"
+#include "clang/AST/DeclObjC.h"
+#include "llvm/Support/raw_ostream.h"
 
 using namespace lldb_private;
 using namespace clang;
 
 ClangASTMetrics::Counters ClangASTMetrics::global_counters = { 0, 0, 0, 0, 0, 0 };
 ClangASTMetrics::Counters ClangASTMetrics::local_counters = { 0, 0, 0, 0, 0, 0 };
 
 void ClangASTMetrics::DumpCounters (Log *log, ClangASTMetrics::Counters &counters)
ClangASTImporter::DeportDecl (clang::ASTContext *dst_ctx,
     if (log)
         log->Printf("    [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p",
                     decl->getDeclKindName(), static_cast<void*>(decl),
                     result->getDeclKindName(), static_cast<void*>(result));
 
     return result;
 }
 
+bool
+ClangASTImporter::CanImport(const CompilerType &type)
+{
+    if (!ClangUtil::IsClangType(type))
+        return false;
+
+    // TODO: remove external completion BOOL
+    // CompleteAndFetchChildren should get the Decl out and check for the
+
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
+
+    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
+    switch (type_class)
+    {
+        case clang::Type::Record:
+        {
+            const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+            if (cxx_record_decl)
+            {
+                if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL))
+                    return true;
+            }
+        }
+        break;
+
+        case clang::Type::Enum:
+        {
+            clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
+            if (enum_decl)
+            {
+                if (ResolveDeclOrigin(enum_decl, NULL, NULL))
+                    return true;
+            }
+        }
+        break;
+
+        case clang::Type::ObjCObject:
+        case clang::Type::ObjCInterface:
+        {
+            const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
+            if (objc_class_type)
+            {
+                clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+                // We currently can't complete objective C types through the newly added ASTContext
+                // because it only supports TagDecl objects right now...
+                if (class_interface_decl)
+                {
+                    if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
+                        return true;
+                }
+            }
+        }
+        break;
+
+        case clang::Type::Typedef:
+            return CanImport(CompilerType(
+                type.GetTypeSystem(),
+                llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()));
+
+        case clang::Type::Auto:
+            return CanImport(CompilerType(type.GetTypeSystem(),
+                                          llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()));
+
+        case clang::Type::Elaborated:
+            return CanImport(CompilerType(
+                type.GetTypeSystem(), llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()));
+
+        case clang::Type::Paren:
+            return CanImport(CompilerType(type.GetTypeSystem(),
+                                          llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
+
+        default:
+            break;
+    }
+
+    return false;
+}
+
+bool
+ClangASTImporter::Import(const CompilerType &type)
+{
+    if (!ClangUtil::IsClangType(type))
+        return false;
+    // TODO: remove external completion BOOL
+    // CompleteAndFetchChildren should get the Decl out and check for the
+
+    clang::QualType qual_type(ClangUtil::GetCanonicalQualType(ClangUtil::RemoveFastQualifiers(type)));
+
+    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
+    switch (type_class)
+    {
+        case clang::Type::Record:
+        {
+            const clang::CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
+            if (cxx_record_decl)
+            {
+                if (ResolveDeclOrigin(cxx_record_decl, NULL, NULL))
+                    return CompleteAndFetchChildren(qual_type);
+            }
+        }
+        break;
+
+        case clang::Type::Enum:
+        {
+            clang::EnumDecl *enum_decl = llvm::cast<clang::EnumType>(qual_type)->getDecl();
+            if (enum_decl)
+            {
+                if (ResolveDeclOrigin(enum_decl, NULL, NULL))
+                    return CompleteAndFetchChildren(qual_type);
+            }
+        }
+        break;
+
+        case clang::Type::ObjCObject:
+        case clang::Type::ObjCInterface:
+        {
+            const clang::ObjCObjectType *objc_class_type = llvm::dyn_cast<clang::ObjCObjectType>(qual_type);
+            if (objc_class_type)
+            {
+                clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
+                // We currently can't complete objective C types through the newly added ASTContext
+                // because it only supports TagDecl objects right now...
+                if (class_interface_decl)
+                {
+                    if (ResolveDeclOrigin(class_interface_decl, NULL, NULL))
+                        return CompleteAndFetchChildren(qual_type);
+                }
+            }
+        }
+        break;
+
+        case clang::Type::Typedef:
+            return Import(CompilerType(
+                type.GetTypeSystem(),
+                llvm::cast<clang::TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr()));
+
+        case clang::Type::Auto:
+            return Import(CompilerType(type.GetTypeSystem(),
+                                       llvm::cast<clang::AutoType>(qual_type)->getDeducedType().getAsOpaquePtr()));
+
+        case clang::Type::Elaborated:
+            return Import(CompilerType(type.GetTypeSystem(),
+                                       llvm::cast<clang::ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr()));
+
+        case clang::Type::Paren:
+            return Import(CompilerType(type.GetTypeSystem(),
+                                       llvm::cast<clang::ParenType>(qual_type)->desugar().getAsOpaquePtr()));
+
+        default:
+            break;
+    }
+    return false;
+}
+
+bool
+ClangASTImporter::CompleteType(const CompilerType &compiler_type)
+{
+    if (!CanImport(compiler_type))
+        return false;
+
+    if (Import(compiler_type))
+    {
+        ClangASTContext::CompleteTagDeclarationDefinition(compiler_type);
+        return true;
+    }
+
+    ClangASTContext::SetHasExternalStorage(compiler_type.GetOpaqueQualType(), false);
+    return false;
+}
+
+bool
+ClangASTImporter::LayoutRecordType(const clang::RecordDecl *record_decl, uint64_t &bit_size, uint64_t &alignment,
+                                   llvm::DenseMap<const clang::FieldDecl *, uint64_t> &field_offsets,
+                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &base_offsets,
+                                   llvm::DenseMap<const clang::CXXRecordDecl *, clang::CharUnits> &vbase_offsets)
+{
+    RecordDeclToLayoutMap::iterator pos = m_record_decl_to_layout_map.find(record_decl);
+    bool success = false;
+    base_offsets.clear();
+    vbase_offsets.clear();
+    if (pos != m_record_decl_to_layout_map.end())
+    {
+        bit_size = pos->second.bit_size;
+        alignment = pos->second.alignment;
+        field_offsets.swap(pos->second.field_offsets);
+        base_offsets.swap(pos->second.base_offsets);
+        vbase_offsets.swap(pos->second.vbase_offsets);
+        m_record_decl_to_layout_map.erase(pos);
+        success = true;
+    }
+    else
+    {
+        bit_size = 0;
+        alignment = 0;
+        field_offsets.clear();
+    }
+    return success;
+}
+
+void
+ClangASTImporter::InsertRecordDecl(clang::RecordDecl *decl, const LayoutInfo &layout)
+{
+    m_record_decl_to_layout_map.insert(std::make_pair(decl, layout));
+}
+
 void
 ClangASTImporter::CompleteDecl (clang::Decl *decl)
 {
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     if (log)
         log->Printf("    [ClangASTImporter] CompleteDecl called on (%sDecl*)%p",
                     decl->getDeclKindName(), static_cast<void*>(decl));

lldb/trunk/source/Symbol/ClangUtil.cpp

+//===-- ClangUtil.cpp -------------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+// A collection of helper methods and data structures for manipulating clang
+// types and decls.
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Symbol/ClangUtil.h"
+#include "lldb/Symbol/ClangASTContext.h"
+
+using namespace clang;
+using namespace lldb_private;
+
+bool
+ClangUtil::IsClangType(const CompilerType &ct)
+{
+    if (llvm::dyn_cast_or_null<ClangASTContext>(ct.GetTypeSystem()) == nullptr)
+        return false;
+
+    if (!ct.GetOpaqueQualType())
+        return false;
+
+    return true;
+}
+
+QualType
+ClangUtil::GetQualType(const CompilerType &ct)
+{
+    // Make sure we have a clang type before making a clang::QualType
+    if (!IsClangType(ct))
+        return QualType();
+
+    return QualType::getFromOpaquePtr(ct.GetOpaqueQualType());
+}
+
+QualType
+ClangUtil::GetCanonicalQualType(const CompilerType &ct)
+{
+    if (!IsClangType(ct))
+        return QualType();
+
+    return GetQualType(ct).getCanonicalType();
+}
+
+CompilerType
+ClangUtil::RemoveFastQualifiers(const CompilerType &ct)
+{
+    if (!IsClangType(ct))
+        return ct;
+
+    QualType qual_type(GetQualType(ct));
+    qual_type.getQualifiers().removeFastQualifiers();
+    return CompilerType(ct.GetTypeSystem(), qual_type.getAsOpaquePtr());
+}