ClangASTContext.cpp revision e2f71a33fa5ffdd3829d0c2c2a6790387743d064 
1//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Symbol/ClangASTContext.h"
11
12// C Includes
13// C++ Includes
14#include <string>
15
16// Other libraries and framework includes
17
18// Clang headers like to use NDEBUG inside of them to enable/disable debug
19// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
20// or another. This is bad because it means that if clang was built in release
21// mode, it assumes that you are building in release mode which is not always
22// the case. You can end up with functions that are defined as empty in header
23// files when NDEBUG is not defined, and this can cause link errors with the
24// clang .a files that you have since you might be missing functions in the .a
25// file. So we have to define NDEBUG when including clang headers to avoid any
26// mismatches. This is covered by rdar://problem/8691220
27
28#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
29#define LLDB_DEFINED_NDEBUG_FOR_CLANG
30#define NDEBUG
31// Need to include assert.h so it is as clang would expect it to be (disabled)
32#include <assert.h>
33#endif
34
35#include "clang/AST/ASTContext.h"
36#include "clang/AST/ASTImporter.h"
37#include "clang/AST/CXXInheritance.h"
38#include "clang/AST/DeclObjC.h"
39#include "clang/AST/DeclTemplate.h"
40#include "clang/AST/RecordLayout.h"
41#include "clang/AST/Type.h"
42#include "clang/Basic/Builtins.h"
43#include "clang/Basic/Diagnostic.h"
44#include "clang/Basic/FileManager.h"
45#include "clang/Basic/FileSystemOptions.h"
46#include "clang/Basic/SourceManager.h"
47#include "clang/Basic/TargetInfo.h"
48#include "clang/Basic/TargetOptions.h"
49#include "clang/Frontend/FrontendOptions.h"
50#include "clang/Frontend/LangStandard.h"
51
52#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
53#undef NDEBUG
54#undef LLDB_DEFINED_NDEBUG_FOR_CLANG
55// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
56#include <assert.h>
57#endif
58
59#include "lldb/Core/ArchSpec.h"
60#include "lldb/Core/dwarf.h"
61#include "lldb/Core/Flags.h"
62#include "lldb/Core/Log.h"
63#include "lldb/Core/RegularExpression.h"
64#include "lldb/Expression/ASTDumper.h"
65#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
66#include "lldb/Symbol/VerifyDecl.h"
67#include "lldb/Target/ExecutionContext.h"
68#include "lldb/Target/Process.h"
69#include "lldb/Target/ObjCLanguageRuntime.h"
70
71
72#include <stdio.h>
73
74using namespace lldb;
75using namespace lldb_private;
76using namespace llvm;
77using namespace clang;
78
79
80static bool
81GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type, bool allow_completion = true)
82{
83    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
84    switch (type_class)
85    {
86    case clang::Type::ConstantArray:
87        {
88            const clang::ArrayType *array_type = dyn_cast<clang::ArrayType>(qual_type.getTypePtr());
89
90            if (array_type)
91                return GetCompleteQualType (ast, array_type->getElementType(), allow_completion);
92        }
93        break;
94
95    case clang::Type::Record:
96    case clang::Type::Enum:
97        {
98            const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
99            if (tag_type)
100            {
101                clang::TagDecl *tag_decl = tag_type->getDecl();
102                if (tag_decl)
103                {
104                    if (tag_decl->isCompleteDefinition())
105                        return true;
106
107                    if (!allow_completion)
108                        return false;
109
110                    if (tag_decl->hasExternalLexicalStorage())
111                    {
112                        if (ast)
113                        {
114                            ExternalASTSource *external_ast_source = ast->getExternalSource();
115                            if (external_ast_source)
116                            {
117                                external_ast_source->CompleteType(tag_decl);
118                                return !tag_type->isIncompleteType();
119                            }
120                        }
121                    }
122                    return false;
123                }
124            }
125
126        }
127        break;
128
129    case clang::Type::ObjCObject:
130    case clang::Type::ObjCInterface:
131        {
132            const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
133            if (objc_class_type)
134            {
135                clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
136                // We currently can't complete objective C types through the newly added ASTContext
137                // because it only supports TagDecl objects right now...
138                if (class_interface_decl)
139                {
140                    if (class_interface_decl->getDefinition())
141                        return true;
142
143                    if (!allow_completion)
144                        return false;
145
146                    if (class_interface_decl->hasExternalLexicalStorage())
147                    {
148                        if (ast)
149                        {
150                            ExternalASTSource *external_ast_source = ast->getExternalSource();
151                            if (external_ast_source)
152                            {
153                                external_ast_source->CompleteType (class_interface_decl);
154                                return !objc_class_type->isIncompleteType();
155                            }
156                        }
157                    }
158                    return false;
159                }
160            }
161        }
162        break;
163
164    case clang::Type::Typedef:
165        return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType(), allow_completion);
166
167    case clang::Type::Elaborated:
168        return GetCompleteQualType (ast, cast<ElaboratedType>(qual_type)->getNamedType(), allow_completion);
169
170    default:
171        break;
172    }
173
174    return true;
175}
176
177static AccessSpecifier
178ConvertAccessTypeToAccessSpecifier (AccessType access)
179{
180    switch (access)
181    {
182    default:               break;
183    case eAccessNone:      return AS_none;
184    case eAccessPublic:    return AS_public;
185    case eAccessPrivate:   return AS_private;
186    case eAccessProtected: return AS_protected;
187    }
188    return AS_none;
189}
190
191static ObjCIvarDecl::AccessControl
192ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
193{
194    switch (access)
195    {
196    default:               break;
197    case eAccessNone:      return ObjCIvarDecl::None;
198    case eAccessPublic:    return ObjCIvarDecl::Public;
199    case eAccessPrivate:   return ObjCIvarDecl::Private;
200    case eAccessProtected: return ObjCIvarDecl::Protected;
201    case eAccessPackage:   return ObjCIvarDecl::Package;
202    }
203    return ObjCIvarDecl::None;
204}
205
206
207static void
208ParseLangArgs
209(
210    LangOptions &Opts,
211    InputKind IK
212)
213{
214    // FIXME: Cleanup per-file based stuff.
215
216    // Set some properties which depend soley on the input kind; it would be nice
217    // to move these to the language standard, and have the driver resolve the
218    // input kind + language standard.
219    if (IK == IK_Asm) {
220        Opts.AsmPreprocessor = 1;
221    } else if (IK == IK_ObjC ||
222               IK == IK_ObjCXX ||
223               IK == IK_PreprocessedObjC ||
224               IK == IK_PreprocessedObjCXX) {
225        Opts.ObjC1 = Opts.ObjC2 = 1;
226    }
227
228    LangStandard::Kind LangStd = LangStandard::lang_unspecified;
229
230    if (LangStd == LangStandard::lang_unspecified) {
231        // Based on the base language, pick one.
232        switch (IK) {
233            case IK_None:
234            case IK_AST:
235            case IK_LLVM_IR:
236                assert (!"Invalid input kind!");
237            case IK_OpenCL:
238                LangStd = LangStandard::lang_opencl;
239                break;
240            case IK_CUDA:
241                LangStd = LangStandard::lang_cuda;
242                break;
243            case IK_Asm:
244            case IK_C:
245            case IK_PreprocessedC:
246            case IK_ObjC:
247            case IK_PreprocessedObjC:
248                LangStd = LangStandard::lang_gnu99;
249                break;
250            case IK_CXX:
251            case IK_PreprocessedCXX:
252            case IK_ObjCXX:
253            case IK_PreprocessedObjCXX:
254                LangStd = LangStandard::lang_gnucxx98;
255                break;
256        }
257    }
258
259    const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
260    Opts.BCPLComment = Std.hasBCPLComments();
261    Opts.C99 = Std.isC99();
262    Opts.CPlusPlus = Std.isCPlusPlus();
263    Opts.CPlusPlus0x = Std.isCPlusPlus0x();
264    Opts.Digraphs = Std.hasDigraphs();
265    Opts.GNUMode = Std.isGNUMode();
266    Opts.GNUInline = !Std.isC99();
267    Opts.HexFloats = Std.hasHexFloats();
268    Opts.ImplicitInt = Std.hasImplicitInt();
269
270    // OpenCL has some additional defaults.
271    if (LangStd == LangStandard::lang_opencl) {
272        Opts.OpenCL = 1;
273        Opts.AltiVec = 1;
274        Opts.CXXOperatorNames = 1;
275        Opts.LaxVectorConversions = 1;
276    }
277
278    // OpenCL and C++ both have bool, true, false keywords.
279    Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
280
281//    if (Opts.CPlusPlus)
282//        Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
283//
284//    if (Args.hasArg(OPT_fobjc_gc_only))
285//        Opts.setGCMode(LangOptions::GCOnly);
286//    else if (Args.hasArg(OPT_fobjc_gc))
287//        Opts.setGCMode(LangOptions::HybridGC);
288//
289//    if (Args.hasArg(OPT_print_ivar_layout))
290//        Opts.ObjCGCBitmapPrint = 1;
291//
292//    if (Args.hasArg(OPT_faltivec))
293//        Opts.AltiVec = 1;
294//
295//    if (Args.hasArg(OPT_pthread))
296//        Opts.POSIXThreads = 1;
297//
298//    llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
299//                                          "default");
300//    if (Vis == "default")
301        Opts.setVisibilityMode(DefaultVisibility);
302//    else if (Vis == "hidden")
303//        Opts.setVisibilityMode(LangOptions::Hidden);
304//    else if (Vis == "protected")
305//        Opts.setVisibilityMode(LangOptions::Protected);
306//    else
307//        Diags.Report(diag::err_drv_invalid_value)
308//        << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
309
310//    Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
311
312    // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
313    // is specified, or -std is set to a conforming mode.
314    Opts.Trigraphs = !Opts.GNUMode;
315//    if (Args.hasArg(OPT_trigraphs))
316//        Opts.Trigraphs = 1;
317//
318//    Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
319//                                     OPT_fno_dollars_in_identifiers,
320//                                     !Opts.AsmPreprocessor);
321//    Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
322//    Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
323//    Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
324//    if (Args.hasArg(OPT_fno_lax_vector_conversions))
325//        Opts.LaxVectorConversions = 0;
326//    Opts.Exceptions = Args.hasArg(OPT_fexceptions);
327//    Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
328//    Opts.Blocks = Args.hasArg(OPT_fblocks);
329//    Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
330//    Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
331//    Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
332//    Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
333//    Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
334//    Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
335//    Opts.AccessControl = Args.hasArg(OPT_faccess_control);
336//    Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
337//    Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
338//    Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
339//                                                 Diags);
340//    Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
341//    Opts.ObjCConstantStringClass = getLastArgValue(Args,
342//                                                   OPT_fconstant_string_class);
343//    Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
344//    Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
345//    Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
346//    Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
347//    Opts.Static = Args.hasArg(OPT_static_define);
348    Opts.OptimizeSize = 0;
349
350    // FIXME: Eliminate this dependency.
351//    unsigned Opt =
352//    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
353//    Opts.Optimize = Opt != 0;
354    unsigned Opt = 0;
355
356    // This is the __NO_INLINE__ define, which just depends on things like the
357    // optimization level and -fno-inline, not actually whether the backend has
358    // inlining enabled.
359    //
360    // FIXME: This is affected by other options (-fno-inline).
361    Opts.NoInline = !Opt;
362
363//    unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
364//    switch (SSP) {
365//        default:
366//            Diags.Report(diag::err_drv_invalid_value)
367//            << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
368//            break;
369//        case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
370//        case 1: Opts.setStackProtectorMode(LangOptions::SSPOn);  break;
371//        case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
372//    }
373}
374
375
376ClangASTContext::ClangASTContext (const char *target_triple) :
377    m_target_triple(),
378    m_ast_ap(),
379    m_language_options_ap(),
380    m_source_manager_ap(),
381    m_diagnostics_engine_ap(),
382    m_target_options_ap(),
383    m_target_info_ap(),
384    m_identifier_table_ap(),
385    m_selector_table_ap(),
386    m_builtins_ap(),
387    m_callback_tag_decl (NULL),
388    m_callback_objc_decl (NULL),
389    m_callback_baton (NULL)
390
391{
392    if (target_triple && target_triple[0])
393        SetTargetTriple (target_triple);
394}
395
396//----------------------------------------------------------------------
397// Destructor
398//----------------------------------------------------------------------
399ClangASTContext::~ClangASTContext()
400{
401    m_builtins_ap.reset();
402    m_selector_table_ap.reset();
403    m_identifier_table_ap.reset();
404    m_target_info_ap.reset();
405    m_target_options_ap.reset();
406    m_diagnostics_engine_ap.reset();
407    m_source_manager_ap.reset();
408    m_language_options_ap.reset();
409    m_ast_ap.reset();
410}
411
412
413void
414ClangASTContext::Clear()
415{
416    m_ast_ap.reset();
417    m_language_options_ap.reset();
418    m_source_manager_ap.reset();
419    m_diagnostics_engine_ap.reset();
420    m_target_options_ap.reset();
421    m_target_info_ap.reset();
422    m_identifier_table_ap.reset();
423    m_selector_table_ap.reset();
424    m_builtins_ap.reset();
425}
426
427const char *
428ClangASTContext::GetTargetTriple ()
429{
430    return m_target_triple.c_str();
431}
432
433void
434ClangASTContext::SetTargetTriple (const char *target_triple)
435{
436    Clear();
437    m_target_triple.assign(target_triple);
438}
439
440void
441ClangASTContext::SetArchitecture (const ArchSpec &arch)
442{
443    SetTargetTriple(arch.GetTriple().str().c_str());
444}
445
446bool
447ClangASTContext::HasExternalSource ()
448{
449    ASTContext *ast = getASTContext();
450    if (ast)
451        return ast->getExternalSource () != NULL;
452    return false;
453}
454
455void
456ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap)
457{
458    ASTContext *ast = getASTContext();
459    if (ast)
460    {
461        ast->setExternalSource (ast_source_ap);
462        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
463        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
464    }
465}
466
467void
468ClangASTContext::RemoveExternalSource ()
469{
470    ASTContext *ast = getASTContext();
471
472    if (ast)
473    {
474        llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap;
475        ast->setExternalSource (empty_ast_source_ap);
476        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
477        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
478    }
479}
480
481
482
483ASTContext *
484ClangASTContext::getASTContext()
485{
486    if (m_ast_ap.get() == NULL)
487    {
488        m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
489                                       *getSourceManager(),
490                                       getTargetInfo(),
491                                       *getIdentifierTable(),
492                                       *getSelectorTable(),
493                                       *getBuiltinContext(),
494                                       0));
495
496        if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
497        {
498            m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
499            //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
500        }
501
502        m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
503    }
504    return m_ast_ap.get();
505}
506
507Builtin::Context *
508ClangASTContext::getBuiltinContext()
509{
510    if (m_builtins_ap.get() == NULL)
511        m_builtins_ap.reset (new Builtin::Context());
512    return m_builtins_ap.get();
513}
514
515IdentifierTable *
516ClangASTContext::getIdentifierTable()
517{
518    if (m_identifier_table_ap.get() == NULL)
519        m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL));
520    return m_identifier_table_ap.get();
521}
522
523LangOptions *
524ClangASTContext::getLanguageOptions()
525{
526    if (m_language_options_ap.get() == NULL)
527    {
528        m_language_options_ap.reset(new LangOptions());
529        ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
530//        InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
531    }
532    return m_language_options_ap.get();
533}
534
535SelectorTable *
536ClangASTContext::getSelectorTable()
537{
538    if (m_selector_table_ap.get() == NULL)
539        m_selector_table_ap.reset (new SelectorTable());
540    return m_selector_table_ap.get();
541}
542
543clang::FileManager *
544ClangASTContext::getFileManager()
545{
546    if (m_file_manager_ap.get() == NULL)
547    {
548        clang::FileSystemOptions file_system_options;
549        m_file_manager_ap.reset(new clang::FileManager(file_system_options));
550    }
551    return m_file_manager_ap.get();
552}
553
554clang::SourceManager *
555ClangASTContext::getSourceManager()
556{
557    if (m_source_manager_ap.get() == NULL)
558        m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));
559    return m_source_manager_ap.get();
560}
561
562clang::DiagnosticsEngine *
563ClangASTContext::getDiagnosticsEngine()
564{
565    if (m_diagnostics_engine_ap.get() == NULL)
566    {
567        llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
568        m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp));
569    }
570    return m_diagnostics_engine_ap.get();
571}
572
573class NullDiagnosticConsumer : public DiagnosticConsumer
574{
575public:
576    NullDiagnosticConsumer ()
577    {
578        m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
579    }
580
581    void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info)
582    {
583        if (m_log)
584        {
585            llvm::SmallVector<char, 32> diag_str(10);
586            info.FormatDiagnostic(diag_str);
587            diag_str.push_back('\0');
588            m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
589        }
590    }
591
592    DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const
593    {
594        return new NullDiagnosticConsumer ();
595    }
596private:
597    LogSP m_log;
598};
599
600DiagnosticConsumer *
601ClangASTContext::getDiagnosticConsumer()
602{
603    if (m_diagnostic_consumer_ap.get() == NULL)
604        m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer);
605
606    return m_diagnostic_consumer_ap.get();
607}
608
609TargetOptions *
610ClangASTContext::getTargetOptions()
611{
612    if (m_target_options_ap.get() == NULL && !m_target_triple.empty())
613    {
614        m_target_options_ap.reset (new TargetOptions());
615        if (m_target_options_ap.get())
616            m_target_options_ap->Triple = m_target_triple;
617    }
618    return m_target_options_ap.get();
619}
620
621
622TargetInfo *
623ClangASTContext::getTargetInfo()
624{
625    // target_triple should be something like "x86_64-apple-darwin10"
626    if (m_target_info_ap.get() == NULL && !m_target_triple.empty())
627        m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), *getTargetOptions()));
628    return m_target_info_ap.get();
629}
630
631#pragma mark Basic Types
632
633static inline bool
634QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
635{
636    uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
637    if (qual_type_bit_size == bit_size)
638        return true;
639    return false;
640}
641
642clang_type_t
643ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
644{
645    ASTContext *ast = getASTContext();
646
647    assert (ast != NULL);
648
649    return GetBuiltinTypeForEncodingAndBitSize (ast, encoding, bit_size);
650}
651
652clang_type_t
653ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
654{
655    if (!ast)
656        return NULL;
657
658    switch (encoding)
659    {
660    case eEncodingInvalid:
661        if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
662            return ast->VoidPtrTy.getAsOpaquePtr();
663        break;
664
665    case eEncodingUint:
666        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
667            return ast->UnsignedCharTy.getAsOpaquePtr();
668        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
669            return ast->UnsignedShortTy.getAsOpaquePtr();
670        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
671            return ast->UnsignedIntTy.getAsOpaquePtr();
672        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
673            return ast->UnsignedLongTy.getAsOpaquePtr();
674        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
675            return ast->UnsignedLongLongTy.getAsOpaquePtr();
676        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
677            return ast->UnsignedInt128Ty.getAsOpaquePtr();
678        break;
679
680    case eEncodingSint:
681        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
682            return ast->CharTy.getAsOpaquePtr();
683        if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
684            return ast->ShortTy.getAsOpaquePtr();
685        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
686            return ast->IntTy.getAsOpaquePtr();
687        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
688            return ast->LongTy.getAsOpaquePtr();
689        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
690            return ast->LongLongTy.getAsOpaquePtr();
691        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
692            return ast->Int128Ty.getAsOpaquePtr();
693        break;
694
695    case eEncodingIEEE754:
696        if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
697            return ast->FloatTy.getAsOpaquePtr();
698        if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
699            return ast->DoubleTy.getAsOpaquePtr();
700        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
701            return ast->LongDoubleTy.getAsOpaquePtr();
702        break;
703
704    case eEncodingVector:
705        // Sanity check that bit_size is a multiple of 8's.
706        if (bit_size && !(bit_size & 0x7u))
707            return ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr();
708        break;
709    default:
710        break;
711    }
712
713    return NULL;
714}
715
716clang_type_t
717ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
718{
719    ASTContext *ast = getASTContext();
720
721#define streq(a,b) strcmp(a,b) == 0
722    assert (ast != NULL);
723    if (ast)
724    {
725        switch (dw_ate)
726        {
727            default:
728                break;
729
730            case DW_ATE_address:
731                if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
732                    return ast->VoidPtrTy.getAsOpaquePtr();
733                break;
734
735            case DW_ATE_boolean:
736                if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
737                    return ast->BoolTy.getAsOpaquePtr();
738                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
739                    return ast->UnsignedCharTy.getAsOpaquePtr();
740                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
741                    return ast->UnsignedShortTy.getAsOpaquePtr();
742                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
743                    return ast->UnsignedIntTy.getAsOpaquePtr();
744                break;
745
746            case DW_ATE_lo_user:
747                // This has been seen to mean DW_AT_complex_integer
748                if (type_name)
749                {
750                    if (::strstr(type_name, "complex"))
751                    {
752                        clang_type_t complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
753                        return ast->getComplexType (QualType::getFromOpaquePtr(complex_int_clang_type)).getAsOpaquePtr();
754                    }
755                }
756                break;
757
758            case DW_ATE_complex_float:
759                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
760                    return ast->FloatComplexTy.getAsOpaquePtr();
761                else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
762                    return ast->DoubleComplexTy.getAsOpaquePtr();
763                else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
764                    return ast->LongDoubleComplexTy.getAsOpaquePtr();
765                else
766                {
767                    clang_type_t complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
768                    return ast->getComplexType (QualType::getFromOpaquePtr(complex_float_clang_type)).getAsOpaquePtr();
769                }
770                break;
771
772            case DW_ATE_float:
773                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
774                    return ast->FloatTy.getAsOpaquePtr();
775                if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
776                    return ast->DoubleTy.getAsOpaquePtr();
777                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
778                    return ast->LongDoubleTy.getAsOpaquePtr();
779                break;
780
781            case DW_ATE_signed:
782                if (type_name)
783                {
784                    if (streq(type_name, "wchar_t") &&
785                        QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
786                        return ast->WCharTy.getAsOpaquePtr();
787                    if (streq(type_name, "void") &&
788                        QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
789                        return ast->VoidTy.getAsOpaquePtr();
790                    if (strstr(type_name, "long long") &&
791                        QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
792                        return ast->LongLongTy.getAsOpaquePtr();
793                    if (strstr(type_name, "long") &&
794                        QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
795                        return ast->LongTy.getAsOpaquePtr();
796                    if (strstr(type_name, "short") &&
797                        QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
798                        return ast->ShortTy.getAsOpaquePtr();
799                    if (strstr(type_name, "char"))
800                    {
801                        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
802                            return ast->CharTy.getAsOpaquePtr();
803                        if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
804                            return ast->SignedCharTy.getAsOpaquePtr();
805                    }
806                    if (strstr(type_name, "int"))
807                    {
808                        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
809                            return ast->IntTy.getAsOpaquePtr();
810                        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
811                            return ast->Int128Ty.getAsOpaquePtr();
812                    }
813                }
814                // We weren't able to match up a type name, just search by size
815                if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
816                    return ast->CharTy.getAsOpaquePtr();
817                if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
818                    return ast->ShortTy.getAsOpaquePtr();
819                if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
820                    return ast->IntTy.getAsOpaquePtr();
821                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
822                    return ast->LongTy.getAsOpaquePtr();
823                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
824                    return ast->LongLongTy.getAsOpaquePtr();
825                if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
826                    return ast->Int128Ty.getAsOpaquePtr();
827                break;
828
829            case DW_ATE_signed_char:
830                if (type_name)
831                {
832                    if (streq(type_name, "signed char"))
833                    {
834                        if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
835                            return ast->SignedCharTy.getAsOpaquePtr();
836                    }
837                }
838                if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
839                    return ast->CharTy.getAsOpaquePtr();
840                if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
841                    return ast->SignedCharTy.getAsOpaquePtr();
842                break;
843
844            case DW_ATE_unsigned:
845                if (type_name)
846                {
847                    if (strstr(type_name, "long long"))
848                    {
849                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
850                            return ast->UnsignedLongLongTy.getAsOpaquePtr();
851                    }
852                    else if (strstr(type_name, "long"))
853                    {
854                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
855                            return ast->UnsignedLongTy.getAsOpaquePtr();
856                    }
857                    else if (strstr(type_name, "short"))
858                    {
859                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
860                            return ast->UnsignedShortTy.getAsOpaquePtr();
861                    }
862                    else if (strstr(type_name, "char"))
863                    {
864                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
865                            return ast->UnsignedCharTy.getAsOpaquePtr();
866                    }
867                    else if (strstr(type_name, "int"))
868                    {
869                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
870                            return ast->UnsignedIntTy.getAsOpaquePtr();
871                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
872                            return ast->UnsignedInt128Ty.getAsOpaquePtr();
873                    }
874                }
875                // We weren't able to match up a type name, just search by size
876                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
877                    return ast->UnsignedCharTy.getAsOpaquePtr();
878                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
879                    return ast->UnsignedShortTy.getAsOpaquePtr();
880                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
881                    return ast->UnsignedIntTy.getAsOpaquePtr();
882                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
883                    return ast->UnsignedLongTy.getAsOpaquePtr();
884                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
885                    return ast->UnsignedLongLongTy.getAsOpaquePtr();
886                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
887                    return ast->UnsignedInt128Ty.getAsOpaquePtr();
888                break;
889
890            case DW_ATE_unsigned_char:
891                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
892                    return ast->UnsignedCharTy.getAsOpaquePtr();
893                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
894                    return ast->UnsignedShortTy.getAsOpaquePtr();
895                break;
896
897            case DW_ATE_imaginary_float:
898                break;
899
900            case DW_ATE_UTF:
901                if (type_name)
902                {
903                    if (streq(type_name, "char16_t"))
904                    {
905                        return ast->Char16Ty.getAsOpaquePtr();
906                    }
907                    else if (streq(type_name, "char32_t"))
908                    {
909                        return ast->Char32Ty.getAsOpaquePtr();
910                    }
911                }
912                break;
913        }
914    }
915    // This assert should fire for anything that we don't catch above so we know
916    // to fix any issues we run into.
917    if (type_name)
918    {
919        Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type '%s' encoded with DW_ATE = 0x%x, bit_size = %u\n", type_name, dw_ate, bit_size);
920    }
921    else
922    {
923        Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size);
924    }
925    return NULL;
926}
927
928clang_type_t
929ClangASTContext::GetBuiltInType_void(ASTContext *ast)
930{
931    return ast->VoidTy.getAsOpaquePtr();
932}
933
934clang_type_t
935ClangASTContext::GetBuiltInType_bool()
936{
937    return getASTContext()->BoolTy.getAsOpaquePtr();
938}
939
940clang_type_t
941ClangASTContext::GetBuiltInType_objc_id()
942{
943    return getASTContext()->getObjCIdType().getAsOpaquePtr();
944}
945
946clang_type_t
947ClangASTContext::GetBuiltInType_objc_Class()
948{
949    return getASTContext()->getObjCClassType().getAsOpaquePtr();
950}
951
952clang_type_t
953ClangASTContext::GetBuiltInType_objc_selector()
954{
955    return getASTContext()->getObjCSelType().getAsOpaquePtr();
956}
957
958clang_type_t
959ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast)
960{
961    return ast->UnknownAnyTy.getAsOpaquePtr();
962}
963
964clang_type_t
965ClangASTContext::GetCStringType (bool is_const)
966{
967    QualType char_type(getASTContext()->CharTy);
968
969    if (is_const)
970        char_type.addConst();
971
972    return getASTContext()->getPointerType(char_type).getAsOpaquePtr();
973}
974
975clang_type_t
976ClangASTContext::GetVoidType()
977{
978    return GetVoidType(getASTContext());
979}
980
981clang_type_t
982ClangASTContext::GetVoidType(ASTContext *ast)
983{
984    return ast->VoidTy.getAsOpaquePtr();
985}
986
987clang_type_t
988ClangASTContext::GetVoidPtrType (bool is_const)
989{
990    return GetVoidPtrType(getASTContext(), is_const);
991}
992
993clang_type_t
994ClangASTContext::GetVoidPtrType (ASTContext *ast, bool is_const)
995{
996    QualType void_ptr_type(ast->VoidPtrTy);
997
998    if (is_const)
999        void_ptr_type.addConst();
1000
1001    return void_ptr_type.getAsOpaquePtr();
1002}
1003
1004clang::DeclContext *
1005ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast)
1006{
1007    return ast->getTranslationUnitDecl();
1008}
1009
1010clang_type_t
1011ClangASTContext::CopyType (ASTContext *dst_ast,
1012                           ASTContext *src_ast,
1013                           clang_type_t clang_type)
1014{
1015    FileSystemOptions file_system_options;
1016    FileManager file_manager (file_system_options);
1017    ASTImporter importer(*dst_ast, file_manager,
1018                         *src_ast, file_manager,
1019                         false);
1020
1021    QualType src (QualType::getFromOpaquePtr(clang_type));
1022    QualType dst (importer.Import(src));
1023
1024    return dst.getAsOpaquePtr();
1025}
1026
1027
1028clang::Decl *
1029ClangASTContext::CopyDecl (ASTContext *dst_ast,
1030                           ASTContext *src_ast,
1031                           clang::Decl *source_decl)
1032{
1033    FileSystemOptions file_system_options;
1034    FileManager file_manager (file_system_options);
1035    ASTImporter importer(*dst_ast, file_manager,
1036                         *src_ast, file_manager,
1037                         false);
1038
1039    return importer.Import(source_decl);
1040}
1041
1042bool
1043ClangASTContext::AreTypesSame (ASTContext *ast,
1044                               clang_type_t type1,
1045                               clang_type_t type2,
1046                               bool ignore_qualifiers)
1047{
1048    if (type1 == type2)
1049        return true;
1050
1051    QualType type1_qual = QualType::getFromOpaquePtr(type1);
1052    QualType type2_qual = QualType::getFromOpaquePtr(type2);
1053
1054    if (ignore_qualifiers)
1055    {
1056        type1_qual = type1_qual.getUnqualifiedType();
1057        type2_qual = type2_qual.getUnqualifiedType();
1058    }
1059
1060    return ast->hasSameType (type1_qual,
1061                             type2_qual);
1062}
1063
1064#pragma mark CVR modifiers
1065
1066clang_type_t
1067ClangASTContext::AddConstModifier (clang_type_t clang_type)
1068{
1069    if (clang_type)
1070    {
1071        QualType result(QualType::getFromOpaquePtr(clang_type));
1072        result.addConst();
1073        return result.getAsOpaquePtr();
1074    }
1075    return NULL;
1076}
1077
1078clang_type_t
1079ClangASTContext::AddRestrictModifier (clang_type_t clang_type)
1080{
1081    if (clang_type)
1082    {
1083        QualType result(QualType::getFromOpaquePtr(clang_type));
1084        result.getQualifiers().setRestrict (true);
1085        return result.getAsOpaquePtr();
1086    }
1087    return NULL;
1088}
1089
1090clang_type_t
1091ClangASTContext::AddVolatileModifier (clang_type_t clang_type)
1092{
1093    if (clang_type)
1094    {
1095        QualType result(QualType::getFromOpaquePtr(clang_type));
1096        result.getQualifiers().setVolatile (true);
1097        return result.getAsOpaquePtr();
1098    }
1099    return NULL;
1100}
1101
1102
1103clang_type_t
1104ClangASTContext::GetTypeForDecl (TagDecl *decl)
1105{
1106    // No need to call the getASTContext() accessor (which can create the AST
1107    // if it isn't created yet, because we can't have created a decl in this
1108    // AST if our AST didn't already exist...
1109    if (m_ast_ap.get())
1110        return m_ast_ap->getTagDeclType(decl).getAsOpaquePtr();
1111    return NULL;
1112}
1113
1114clang_type_t
1115ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
1116{
1117    // No need to call the getASTContext() accessor (which can create the AST
1118    // if it isn't created yet, because we can't have created a decl in this
1119    // AST if our AST didn't already exist...
1120    if (m_ast_ap.get())
1121        return m_ast_ap->getObjCInterfaceType(decl).getAsOpaquePtr();
1122    return NULL;
1123}
1124
1125#pragma mark Structure, Unions, Classes
1126
1127clang_type_t
1128ClangASTContext::CreateRecordType (DeclContext *decl_ctx, AccessType access_type, const char *name, int kind, LanguageType language)
1129{
1130    ASTContext *ast = getASTContext();
1131    assert (ast != NULL);
1132
1133    if (decl_ctx == NULL)
1134        decl_ctx = ast->getTranslationUnitDecl();
1135
1136
1137    if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus)
1138    {
1139        bool isForwardDecl = true;
1140        bool isInternal = false;
1141        return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal);
1142    }
1143
1144    // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1145    // we will need to update this code. I was told to currently always use
1146    // the CXXRecordDecl class since we often don't know from debug information
1147    // if something is struct or a class, so we default to always use the more
1148    // complete definition just in case.
1149    CXXRecordDecl *decl = CXXRecordDecl::Create (*ast,
1150                                                 (TagDecl::TagKind)kind,
1151                                                 decl_ctx,
1152                                                 SourceLocation(),
1153                                                 SourceLocation(),
1154                                                 name && name[0] ? &ast->Idents.get(name) : NULL);
1155
1156    if (!name)
1157        decl->setAnonymousStructOrUnion(true);
1158
1159    if (decl_ctx)
1160    {
1161        if (access_type != eAccessNone)
1162            decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1163        decl_ctx->addDecl (decl);
1164    }
1165    return ast->getTagDeclType(decl).getAsOpaquePtr();
1166}
1167
1168static TemplateParameterList *
1169CreateTemplateParameterList (ASTContext *ast,
1170                             const ClangASTContext::TemplateParameterInfos &template_param_infos,
1171                             llvm::SmallVector<NamedDecl *, 8> &template_param_decls)
1172{
1173    const bool parameter_pack = false;
1174    const bool is_typename = false;
1175    const unsigned depth = 0;
1176    const size_t num_template_params = template_param_infos.GetSize();
1177    for (size_t i=0; i<num_template_params; ++i)
1178    {
1179        const char *name = template_param_infos.names[i];
1180        if (template_param_infos.args[i].getAsIntegral())
1181        {
1182            template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast,
1183                                                                             ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc,
1184                                                                             SourceLocation(),
1185                                                                             SourceLocation(),
1186                                                                             depth,
1187                                                                             i,
1188                                                                             &ast->Idents.get(name),
1189                                                                             template_param_infos.args[i].getIntegralType(),
1190                                                                             parameter_pack,
1191                                                                             NULL));
1192
1193        }
1194        else
1195        {
1196            template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast,
1197                                                                          ast->getTranslationUnitDecl(), // Is this the right decl context?
1198                                                                          SourceLocation(),
1199                                                                          SourceLocation(),
1200                                                                          depth,
1201                                                                          i,
1202                                                                          &ast->Idents.get(name),
1203                                                                          is_typename,
1204                                                                          parameter_pack));
1205        }
1206    }
1207
1208    TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast,
1209                                                                                SourceLocation(),
1210                                                                                SourceLocation(),
1211                                                                                &template_param_decls.front(),
1212                                                                                template_param_decls.size(),
1213                                                                                SourceLocation());
1214    return template_param_list;
1215}
1216
1217clang::FunctionTemplateDecl *
1218ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx,
1219                                             clang::FunctionDecl *func_decl,
1220                                             const char *name,
1221                                             const TemplateParameterInfos &template_param_infos)
1222{
1223//    /// \brief Create a function template node.
1224    ASTContext *ast = getASTContext();
1225
1226    llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1227
1228    TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1229                                                                              template_param_infos,
1230                                                                              template_param_decls);
1231    FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast,
1232                                                                         decl_ctx,
1233                                                                         func_decl->getLocation(),
1234                                                                         func_decl->getDeclName(),
1235                                                                         template_param_list,
1236                                                                         func_decl);
1237
1238    for (size_t i=0, template_param_decl_count = template_param_decls.size();
1239         i < template_param_decl_count;
1240         ++i)
1241    {
1242        // TODO: verify which decl context we should put template_param_decls into..
1243        template_param_decls[i]->setDeclContext (func_decl);
1244    }
1245
1246    return func_tmpl_decl;
1247}
1248
1249void
1250ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl,
1251                                                           clang::FunctionTemplateDecl *func_tmpl_decl,
1252                                                           const TemplateParameterInfos &infos)
1253{
1254    TemplateArgumentList template_args (TemplateArgumentList::OnStack,
1255                                        infos.args.data(),
1256                                        infos.args.size());
1257
1258    func_decl->setFunctionTemplateSpecialization (func_tmpl_decl,
1259                                                  &template_args,
1260                                                  NULL);
1261}
1262
1263
1264ClassTemplateDecl *
1265ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx,
1266                                          lldb::AccessType access_type,
1267                                          const char *class_name,
1268                                          int kind,
1269                                          const TemplateParameterInfos &template_param_infos)
1270{
1271    ASTContext *ast = getASTContext();
1272
1273    ClassTemplateDecl *class_template_decl = NULL;
1274    if (decl_ctx == NULL)
1275        decl_ctx = ast->getTranslationUnitDecl();
1276
1277    IdentifierInfo &identifier_info = ast->Idents.get(class_name);
1278    DeclarationName decl_name (&identifier_info);
1279
1280    clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1281    for (clang::DeclContext::lookup_iterator pos = result.first, end = result.second; pos != end; ++pos)
1282    {
1283        class_template_decl = dyn_cast<clang::ClassTemplateDecl>(*pos);
1284        if (class_template_decl)
1285            return class_template_decl;
1286    }
1287
1288    llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1289
1290    TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1291                                                                              template_param_infos,
1292                                                                              template_param_decls);
1293
1294    CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast,
1295                                                              (TagDecl::TagKind)kind,
1296                                                              decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1297                                                              SourceLocation(),
1298                                                              SourceLocation(),
1299                                                              &identifier_info);
1300
1301    for (size_t i=0, template_param_decl_count = template_param_decls.size();
1302         i < template_param_decl_count;
1303         ++i)
1304    {
1305        template_param_decls[i]->setDeclContext (template_cxx_decl);
1306    }
1307
1308    // With templated classes, we say that a class is templated with
1309    // specializations, but that the bare class has no functions.
1310    template_cxx_decl->startDefinition();
1311    template_cxx_decl->completeDefinition();
1312
1313    class_template_decl = ClassTemplateDecl::Create (*ast,
1314                                                     decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1315                                                     SourceLocation(),
1316                                                     decl_name,
1317                                                     template_param_list,
1318                                                     template_cxx_decl,
1319                                                     NULL);
1320
1321    if (class_template_decl)
1322    {
1323        if (access_type != eAccessNone)
1324            class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1325
1326        //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
1327        //    CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
1328
1329        decl_ctx->addDecl (class_template_decl);
1330
1331#ifdef LLDB_CONFIGURATION_DEBUG
1332        VerifyDecl(class_template_decl);
1333#endif
1334    }
1335
1336    return class_template_decl;
1337}
1338
1339
1340ClassTemplateSpecializationDecl *
1341ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx,
1342                                                        ClassTemplateDecl *class_template_decl,
1343                                                        int kind,
1344                                                        const TemplateParameterInfos &template_param_infos)
1345{
1346    ASTContext *ast = getASTContext();
1347    ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast,
1348                                                                                                                   (TagDecl::TagKind)kind,
1349                                                                                                                   decl_ctx,
1350                                                                                                                   SourceLocation(),
1351                                                                                                                   SourceLocation(),
1352                                                                                                                   class_template_decl,
1353                                                                                                                   &template_param_infos.args.front(),
1354                                                                                                                   template_param_infos.args.size(),
1355                                                                                                                   NULL);
1356
1357    return class_template_specialization_decl;
1358}
1359
1360lldb::clang_type_t
1361ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl)
1362{
1363    if (class_template_specialization_decl)
1364    {
1365        ASTContext *ast = getASTContext();
1366        if (ast)
1367            return ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr();
1368    }
1369    return NULL;
1370}
1371
1372bool
1373ClangASTContext::SetHasExternalStorage (clang_type_t clang_type, bool has_extern)
1374{
1375    if (clang_type == NULL)
1376        return false;
1377
1378    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1379
1380    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1381    switch (type_class)
1382    {
1383    case clang::Type::Record:
1384        {
1385            CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
1386            if (cxx_record_decl)
1387            {
1388                cxx_record_decl->setHasExternalLexicalStorage (has_extern);
1389                cxx_record_decl->setHasExternalVisibleStorage (has_extern);
1390                return true;
1391            }
1392        }
1393        break;
1394
1395    case clang::Type::Enum:
1396        {
1397            EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl();
1398            if (enum_decl)
1399            {
1400                enum_decl->setHasExternalLexicalStorage (has_extern);
1401                enum_decl->setHasExternalVisibleStorage (has_extern);
1402                return true;
1403            }
1404        }
1405        break;
1406
1407    case clang::Type::ObjCObject:
1408    case clang::Type::ObjCInterface:
1409        {
1410            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
1411            assert (objc_class_type);
1412            if (objc_class_type)
1413            {
1414                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1415
1416                if (class_interface_decl)
1417                {
1418                    class_interface_decl->setHasExternalLexicalStorage (has_extern);
1419                    class_interface_decl->setHasExternalVisibleStorage (has_extern);
1420                    return true;
1421                }
1422            }
1423        }
1424        break;
1425
1426    case clang::Type::Typedef:
1427        return ClangASTContext::SetHasExternalStorage (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern);
1428
1429    case clang::Type::Elaborated:
1430        return ClangASTContext::SetHasExternalStorage (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), has_extern);
1431
1432    default:
1433        break;
1434    }
1435    return false;
1436}
1437
1438static bool
1439IsOperator (const char *name, OverloadedOperatorKind &op_kind)
1440{
1441    if (name == NULL || name[0] == '\0')
1442        return false;
1443
1444#define OPERATOR_PREFIX "operator"
1445#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
1446
1447    const char *post_op_name = NULL;
1448
1449    bool no_space = true;
1450
1451    if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
1452        return false;
1453
1454    post_op_name = name + OPERATOR_PREFIX_LENGTH;
1455
1456    if (post_op_name[0] == ' ')
1457    {
1458        post_op_name++;
1459        no_space = false;
1460    }
1461
1462#undef OPERATOR_PREFIX
1463#undef OPERATOR_PREFIX_LENGTH
1464
1465    // This is an operator, set the overloaded operator kind to invalid
1466    // in case this is a conversion operator...
1467    op_kind = NUM_OVERLOADED_OPERATORS;
1468
1469    switch (post_op_name[0])
1470    {
1471    default:
1472        if (no_space)
1473            return false;
1474        break;
1475    case 'n':
1476        if (no_space)
1477            return false;
1478        if  (strcmp (post_op_name, "new") == 0)
1479            op_kind = OO_New;
1480        else if (strcmp (post_op_name, "new[]") == 0)
1481            op_kind = OO_Array_New;
1482        break;
1483
1484    case 'd':
1485        if (no_space)
1486            return false;
1487        if (strcmp (post_op_name, "delete") == 0)
1488            op_kind = OO_Delete;
1489        else if (strcmp (post_op_name, "delete[]") == 0)
1490            op_kind = OO_Array_Delete;
1491        break;
1492
1493    case '+':
1494        if (post_op_name[1] == '\0')
1495            op_kind = OO_Plus;
1496        else if (post_op_name[2] == '\0')
1497        {
1498            if (post_op_name[1] == '=')
1499                op_kind = OO_PlusEqual;
1500            else if (post_op_name[1] == '+')
1501                op_kind = OO_PlusPlus;
1502        }
1503        break;
1504
1505    case '-':
1506        if (post_op_name[1] == '\0')
1507            op_kind = OO_Minus;
1508        else if (post_op_name[2] == '\0')
1509        {
1510            switch (post_op_name[1])
1511            {
1512            case '=': op_kind = OO_MinusEqual; break;
1513            case '-': op_kind = OO_MinusMinus; break;
1514            case '>': op_kind = OO_Arrow; break;
1515            }
1516        }
1517        else if (post_op_name[3] == '\0')
1518        {
1519            if (post_op_name[2] == '*')
1520                op_kind = OO_ArrowStar; break;
1521        }
1522        break;
1523
1524    case '*':
1525        if (post_op_name[1] == '\0')
1526            op_kind = OO_Star;
1527        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1528            op_kind = OO_StarEqual;
1529        break;
1530
1531    case '/':
1532        if (post_op_name[1] == '\0')
1533            op_kind = OO_Slash;
1534        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1535            op_kind = OO_SlashEqual;
1536        break;
1537
1538    case '%':
1539        if (post_op_name[1] == '\0')
1540            op_kind = OO_Percent;
1541        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1542            op_kind = OO_PercentEqual;
1543        break;
1544
1545
1546    case '^':
1547        if (post_op_name[1] == '\0')
1548            op_kind = OO_Caret;
1549        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1550            op_kind = OO_CaretEqual;
1551        break;
1552
1553    case '&':
1554        if (post_op_name[1] == '\0')
1555            op_kind = OO_Amp;
1556        else if (post_op_name[2] == '\0')
1557        {
1558            switch (post_op_name[1])
1559            {
1560            case '=': op_kind = OO_AmpEqual; break;
1561            case '&': op_kind = OO_AmpAmp; break;
1562            }
1563        }
1564        break;
1565
1566    case '|':
1567        if (post_op_name[1] == '\0')
1568            op_kind = OO_Pipe;
1569        else if (post_op_name[2] == '\0')
1570        {
1571            switch (post_op_name[1])
1572            {
1573            case '=': op_kind = OO_PipeEqual; break;
1574            case '|': op_kind = OO_PipePipe; break;
1575            }
1576        }
1577        break;
1578
1579    case '~':
1580        if (post_op_name[1] == '\0')
1581            op_kind = OO_Tilde;
1582        break;
1583
1584    case '!':
1585        if (post_op_name[1] == '\0')
1586            op_kind = OO_Exclaim;
1587        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1588            op_kind = OO_ExclaimEqual;
1589        break;
1590
1591    case '=':
1592        if (post_op_name[1] == '\0')
1593            op_kind = OO_Equal;
1594        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1595            op_kind = OO_EqualEqual;
1596        break;
1597
1598    case '<':
1599        if (post_op_name[1] == '\0')
1600            op_kind = OO_Less;
1601        else if (post_op_name[2] == '\0')
1602        {
1603            switch (post_op_name[1])
1604            {
1605            case '<': op_kind = OO_LessLess; break;
1606            case '=': op_kind = OO_LessEqual; break;
1607            }
1608        }
1609        else if (post_op_name[3] == '\0')
1610        {
1611            if (post_op_name[2] == '=')
1612                op_kind = OO_LessLessEqual;
1613        }
1614        break;
1615
1616    case '>':
1617        if (post_op_name[1] == '\0')
1618            op_kind = OO_Greater;
1619        else if (post_op_name[2] == '\0')
1620        {
1621            switch (post_op_name[1])
1622            {
1623            case '>': op_kind = OO_GreaterGreater; break;
1624            case '=': op_kind = OO_GreaterEqual; break;
1625            }
1626        }
1627        else if (post_op_name[1] == '>' &&
1628                 post_op_name[2] == '=' &&
1629                 post_op_name[3] == '\0')
1630        {
1631                op_kind = OO_GreaterGreaterEqual;
1632        }
1633        break;
1634
1635    case ',':
1636        if (post_op_name[1] == '\0')
1637            op_kind = OO_Comma;
1638        break;
1639
1640    case '(':
1641        if (post_op_name[1] == ')' && post_op_name[2] == '\0')
1642            op_kind = OO_Call;
1643        break;
1644
1645    case '[':
1646        if (post_op_name[1] == ']' && post_op_name[2] == '\0')
1647            op_kind = OO_Subscript;
1648        break;
1649    }
1650
1651    return true;
1652}
1653
1654static inline bool
1655check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
1656{
1657    // Special-case call since it can take any number of operands
1658    if(op_kind == OO_Call)
1659        return true;
1660
1661    // The parameter count doens't include "this"
1662    if (num_params == 0)
1663        return unary;
1664    if (num_params == 1)
1665        return binary;
1666    else
1667    return false;
1668}
1669
1670bool
1671ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params)
1672{
1673    switch (op_kind)
1674    {
1675    default:
1676        break;
1677    // C++ standard allows any number of arguments to new/delete
1678    case OO_New:
1679    case OO_Array_New:
1680    case OO_Delete:
1681    case OO_Array_Delete:
1682        return true;
1683    }
1684
1685#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params);
1686    switch (op_kind)
1687    {
1688#include "clang/Basic/OperatorKinds.def"
1689        default: break;
1690    }
1691    return false;
1692}
1693
1694CXXMethodDecl *
1695ClangASTContext::AddMethodToCXXRecordType
1696(
1697    ASTContext *ast,
1698    clang_type_t record_opaque_type,
1699    const char *name,
1700    clang_type_t method_opaque_type,
1701    lldb::AccessType access,
1702    bool is_virtual,
1703    bool is_static,
1704    bool is_inline,
1705    bool is_explicit,
1706    bool is_attr_used,
1707    bool is_artificial
1708)
1709{
1710    if (!record_opaque_type || !method_opaque_type || !name)
1711        return NULL;
1712
1713    assert(ast);
1714
1715    IdentifierTable *identifier_table = &ast->Idents;
1716
1717    assert(identifier_table);
1718
1719    QualType record_qual_type(QualType::getFromOpaquePtr(record_opaque_type));
1720
1721    CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
1722
1723    if (cxx_record_decl == NULL)
1724        return NULL;
1725
1726    QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
1727
1728    CXXMethodDecl *cxx_method_decl = NULL;
1729
1730    DeclarationName decl_name (&identifier_table->get(name));
1731
1732    const clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
1733
1734    if (function_Type == NULL)
1735        return NULL;
1736
1737    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
1738
1739    if (!method_function_prototype)
1740        return NULL;
1741
1742    unsigned int num_params = method_function_prototype->getNumArgs();
1743
1744    CXXDestructorDecl *cxx_dtor_decl(NULL);
1745    CXXConstructorDecl *cxx_ctor_decl(NULL);
1746
1747    if (name[0] == '~')
1748    {
1749        cxx_dtor_decl = CXXDestructorDecl::Create (*ast,
1750                                                   cxx_record_decl,
1751                                                   SourceLocation(),
1752                                                   DeclarationNameInfo (ast->DeclarationNames.getCXXDestructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
1753                                                   method_qual_type,
1754                                                   NULL,
1755                                                   is_inline,
1756                                                   is_artificial);
1757        cxx_method_decl = cxx_dtor_decl;
1758    }
1759    else if (decl_name == cxx_record_decl->getDeclName())
1760    {
1761       cxx_ctor_decl = CXXConstructorDecl::Create (*ast,
1762                                                   cxx_record_decl,
1763                                                   SourceLocation(),
1764                                                   DeclarationNameInfo (ast->DeclarationNames.getCXXConstructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
1765                                                   method_qual_type,
1766                                                   NULL, // TypeSourceInfo *
1767                                                   is_explicit,
1768                                                   is_inline,
1769                                                   is_artificial,
1770                                                   false /*is_constexpr*/);
1771        cxx_method_decl = cxx_ctor_decl;
1772    }
1773    else
1774    {
1775
1776        OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
1777        if (IsOperator (name, op_kind))
1778        {
1779            if (op_kind != NUM_OVERLOADED_OPERATORS)
1780            {
1781                // Check the number of operator parameters. Sometimes we have
1782                // seen bad DWARF that doesn't correctly describe operators and
1783                // if we try to create a methed and add it to the class, clang
1784                // will assert and crash, so we need to make sure things are
1785                // acceptable.
1786                if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
1787                    return NULL;
1788                cxx_method_decl = CXXMethodDecl::Create (*ast,
1789                                                         cxx_record_decl,
1790                                                         SourceLocation(),
1791                                                         DeclarationNameInfo (ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
1792                                                         method_qual_type,
1793                                                         NULL, // TypeSourceInfo *
1794                                                         is_static,
1795                                                         SC_None,
1796                                                         is_inline,
1797                                                         false /*is_constexpr*/,
1798                                                         SourceLocation());
1799            }
1800            else if (num_params == 0)
1801            {
1802                // Conversion operators don't take params...
1803                cxx_method_decl = CXXConversionDecl::Create (*ast,
1804                                                             cxx_record_decl,
1805                                                             SourceLocation(),
1806                                                             DeclarationNameInfo (ast->DeclarationNames.getCXXConversionFunctionName (ast->getCanonicalType (function_Type->getResultType())), SourceLocation()),
1807                                                             method_qual_type,
1808                                                             NULL, // TypeSourceInfo *
1809                                                             is_inline,
1810                                                             is_explicit,
1811                                                             false /*is_constexpr*/,
1812                                                             SourceLocation());
1813            }
1814        }
1815
1816        if (cxx_method_decl == NULL)
1817        {
1818            cxx_method_decl = CXXMethodDecl::Create (*ast,
1819                                                     cxx_record_decl,
1820                                                     SourceLocation(),
1821                                                     DeclarationNameInfo (decl_name, SourceLocation()),
1822                                                     method_qual_type,
1823                                                     NULL, // TypeSourceInfo *
1824                                                     is_static,
1825                                                     SC_None,
1826                                                     is_inline,
1827                                                     false /*is_constexpr*/,
1828                                                     SourceLocation());
1829        }
1830    }
1831
1832    AccessSpecifier access_specifier = ConvertAccessTypeToAccessSpecifier (access);
1833
1834    cxx_method_decl->setAccess (access_specifier);
1835    cxx_method_decl->setVirtualAsWritten (is_virtual);
1836
1837    if (is_attr_used)
1838        cxx_method_decl->addAttr(::new (*ast) UsedAttr(SourceRange(), *ast));
1839
1840    // Populate the method decl with parameter decls
1841
1842    llvm::SmallVector<ParmVarDecl *, 12> params;
1843
1844    for (int param_index = 0;
1845         param_index < num_params;
1846         ++param_index)
1847    {
1848        params.push_back (ParmVarDecl::Create (*ast,
1849                                               cxx_method_decl,
1850                                               SourceLocation(),
1851                                               SourceLocation(),
1852                                               NULL, // anonymous
1853                                               method_function_prototype->getArgType(param_index),
1854                                               NULL,
1855                                               SC_None,
1856                                               SC_None,
1857                                               NULL));
1858    }
1859
1860    cxx_method_decl->setParams (ArrayRef<ParmVarDecl*>(params));
1861
1862    cxx_record_decl->addDecl (cxx_method_decl);
1863
1864    // Sometimes the debug info will mention a constructor (default/copy/move),
1865    // destructor, or assignment operator (copy/move) but there won't be any
1866    // version of this in the code. So we check if the function was artificially
1867    // generated and if it is trivial and this lets the compiler/backend know
1868    // that it can inline the IR for these when it needs to and we can avoid a
1869    // "missing function" error when running expressions.
1870
1871    if (is_artificial)
1872    {
1873        if (cxx_ctor_decl &&
1874            ((cxx_ctor_decl->isDefaultConstructor() && cxx_record_decl->hasTrivialDefaultConstructor ()) ||
1875             (cxx_ctor_decl->isCopyConstructor()    && cxx_record_decl->hasTrivialCopyConstructor    ()) ||
1876             (cxx_ctor_decl->isMoveConstructor()    && cxx_record_decl->hasTrivialMoveConstructor    ()) ))
1877        {
1878            cxx_ctor_decl->setDefaulted();
1879            cxx_ctor_decl->setTrivial(true);
1880        }
1881        else if (cxx_dtor_decl)
1882        {
1883            if (cxx_record_decl->hasTrivialDestructor())
1884            {
1885                cxx_dtor_decl->setDefaulted();
1886                cxx_dtor_decl->setTrivial(true);
1887            }
1888        }
1889        else if ((cxx_method_decl->isCopyAssignmentOperator() && cxx_record_decl->hasTrivialCopyAssignment()) ||
1890                 (cxx_method_decl->isMoveAssignmentOperator() && cxx_record_decl->hasTrivialMoveAssignment()))
1891        {
1892            cxx_method_decl->setDefaulted();
1893            cxx_method_decl->setTrivial(true);
1894        }
1895    }
1896
1897#ifdef LLDB_CONFIGURATION_DEBUG
1898    VerifyDecl(cxx_method_decl);
1899#endif
1900
1901//    printf ("decl->isPolymorphic()             = %i\n", cxx_record_decl->isPolymorphic());
1902//    printf ("decl->isAggregate()               = %i\n", cxx_record_decl->isAggregate());
1903//    printf ("decl->isPOD()                     = %i\n", cxx_record_decl->isPOD());
1904//    printf ("decl->isEmpty()                   = %i\n", cxx_record_decl->isEmpty());
1905//    printf ("decl->isAbstract()                = %i\n", cxx_record_decl->isAbstract());
1906//    printf ("decl->hasTrivialConstructor()     = %i\n", cxx_record_decl->hasTrivialConstructor());
1907//    printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor());
1908//    printf ("decl->hasTrivialCopyAssignment()  = %i\n", cxx_record_decl->hasTrivialCopyAssignment());
1909//    printf ("decl->hasTrivialDestructor()      = %i\n", cxx_record_decl->hasTrivialDestructor());
1910    return cxx_method_decl;
1911}
1912
1913clang::FieldDecl *
1914ClangASTContext::AddFieldToRecordType
1915(
1916    ASTContext *ast,
1917    clang_type_t record_clang_type,
1918    const char *name,
1919    clang_type_t field_type,
1920    AccessType access,
1921    uint32_t bitfield_bit_size
1922)
1923{
1924    if (record_clang_type == NULL || field_type == NULL)
1925        return NULL;
1926
1927    FieldDecl *field = NULL;
1928    IdentifierTable *identifier_table = &ast->Idents;
1929
1930    assert (ast != NULL);
1931    assert (identifier_table != NULL);
1932
1933    QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
1934
1935    const clang::Type *clang_type = record_qual_type.getTypePtr();
1936    if (clang_type)
1937    {
1938        const RecordType *record_type = dyn_cast<RecordType>(clang_type);
1939
1940        if (record_type)
1941        {
1942            RecordDecl *record_decl = record_type->getDecl();
1943
1944            clang::Expr *bit_width = NULL;
1945            if (bitfield_bit_size != 0)
1946            {
1947                APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
1948                bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
1949            }
1950            field = FieldDecl::Create (*ast,
1951                                                  record_decl,
1952                                                  SourceLocation(),
1953                                                  SourceLocation(),
1954                                                  name ? &identifier_table->get(name) : NULL, // Identifier
1955                                                  QualType::getFromOpaquePtr(field_type), // Field type
1956                                                  NULL,       // TInfo *
1957                                                  bit_width,  // BitWidth
1958                                                  false,      // Mutable
1959                                                  false);     // HasInit
1960
1961            if (!name)
1962                field->setImplicit();
1963
1964            field->setAccess (ConvertAccessTypeToAccessSpecifier (access));
1965
1966            if (field)
1967            {
1968                record_decl->addDecl(field);
1969
1970#ifdef LLDB_CONFIGURATION_DEBUG
1971                VerifyDecl(field);
1972#endif
1973            }
1974        }
1975        else
1976        {
1977            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
1978            if (objc_class_type)
1979            {
1980                bool is_synthesized = false;
1981                field = ClangASTContext::AddObjCClassIVar (ast,
1982                                                   record_clang_type,
1983                                                   name,
1984                                                   field_type,
1985                                                   access,
1986                                                   bitfield_bit_size,
1987                                                   is_synthesized);
1988            }
1989        }
1990    }
1991    return field;
1992}
1993
1994static clang::AccessSpecifier UnifyAccessSpecifiers (clang::AccessSpecifier lhs,
1995                                                     clang::AccessSpecifier rhs)
1996{
1997    clang::AccessSpecifier ret = lhs;
1998
1999    // Make the access equal to the stricter of the field and the nested field's access
2000    switch (ret)
2001    {
2002        case clang::AS_none:
2003            break;
2004        case clang::AS_private:
2005            break;
2006        case clang::AS_protected:
2007            if (rhs == AS_private)
2008                ret = AS_private;
2009            break;
2010        case clang::AS_public:
2011            ret = rhs;
2012            break;
2013    }
2014
2015    return ret;
2016}
2017
2018void
2019ClangASTContext::BuildIndirectFields (clang::ASTContext *ast,
2020                                      lldb::clang_type_t record_clang_type)
2021{
2022    QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
2023
2024    const RecordType *record_type = record_qual_type->getAs<RecordType>();
2025
2026    if (!record_type)
2027        return;
2028
2029    RecordDecl *record_decl = record_type->getDecl();
2030
2031    if (!record_decl)
2032        return;
2033
2034    typedef llvm::SmallVector <IndirectFieldDecl *, 1> IndirectFieldVector;
2035
2036    IndirectFieldVector indirect_fields;
2037
2038    for (RecordDecl::field_iterator fi = record_decl->field_begin(), fe = record_decl->field_end();
2039         fi != fe;
2040         ++fi)
2041    {
2042        if (fi->isAnonymousStructOrUnion())
2043        {
2044            QualType field_qual_type = fi->getType();
2045
2046            const RecordType *field_record_type = field_qual_type->getAs<RecordType>();
2047
2048            if (!field_record_type)
2049                continue;
2050
2051            RecordDecl *field_record_decl = field_record_type->getDecl();
2052
2053            if (!field_record_decl)
2054                continue;
2055
2056            for (RecordDecl::decl_iterator di = field_record_decl->decls_begin(), de = field_record_decl->decls_end();
2057                 di != de;
2058                 ++di)
2059            {
2060                if (FieldDecl *nested_field_decl = dyn_cast<FieldDecl>(*di))
2061                {
2062                    NamedDecl **chain = new (*ast) NamedDecl*[2];
2063                    chain[0] = *fi;
2064                    chain[1] = nested_field_decl;
2065                    IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*ast,
2066                                                                                  record_decl,
2067                                                                                  SourceLocation(),
2068                                                                                  nested_field_decl->getIdentifier(),
2069                                                                                  nested_field_decl->getType(),
2070                                                                                  chain,
2071                                                                                  2);
2072
2073                    indirect_field->setAccess(UnifyAccessSpecifiers(fi->getAccess(),
2074                                                                    nested_field_decl->getAccess()));
2075
2076                    indirect_fields.push_back(indirect_field);
2077                }
2078                else if (IndirectFieldDecl *nested_indirect_field_decl = dyn_cast<IndirectFieldDecl>(*di))
2079                {
2080                    int nested_chain_size = nested_indirect_field_decl->getChainingSize();
2081                    NamedDecl **chain = new (*ast) NamedDecl*[nested_chain_size + 1];
2082                    chain[0] = *fi;
2083
2084                    int chain_index = 1;
2085                    for (IndirectFieldDecl::chain_iterator nci = nested_indirect_field_decl->chain_begin(),
2086                         nce = nested_indirect_field_decl->chain_end();
2087                         nci < nce;
2088                         ++nci)
2089                    {
2090                        chain[chain_index] = *nci;
2091                        chain_index++;
2092                    }
2093
2094                    IndirectFieldDecl *indirect_field = IndirectFieldDecl::Create(*ast,
2095                                                                                  record_decl,
2096                                                                                  SourceLocation(),
2097                                                                                  nested_indirect_field_decl->getIdentifier(),
2098                                                                                  nested_indirect_field_decl->getType(),
2099                                                                                  chain,
2100                                                                                  nested_chain_size + 1);
2101
2102                    indirect_field->setAccess(UnifyAccessSpecifiers(fi->getAccess(),
2103                                                                    nested_indirect_field_decl->getAccess()));
2104
2105                    indirect_fields.push_back(indirect_field);
2106                }
2107            }
2108        }
2109    }
2110
2111    for (IndirectFieldVector::iterator ifi = indirect_fields.begin(), ife = indirect_fields.end();
2112         ifi < ife;
2113         ++ifi)
2114    {
2115        record_decl->addDecl(*ifi);
2116    }
2117}
2118
2119bool
2120ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
2121{
2122    return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
2123}
2124
2125bool
2126ClangASTContext::FieldIsBitfield
2127(
2128    ASTContext *ast,
2129    FieldDecl* field,
2130    uint32_t& bitfield_bit_size
2131)
2132{
2133    if (ast == NULL || field == NULL)
2134        return false;
2135
2136    if (field->isBitField())
2137    {
2138        Expr* bit_width_expr = field->getBitWidth();
2139        if (bit_width_expr)
2140        {
2141            llvm::APSInt bit_width_apsint;
2142            if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
2143            {
2144                bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
2145                return true;
2146            }
2147        }
2148    }
2149    return false;
2150}
2151
2152bool
2153ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
2154{
2155    if (record_decl == NULL)
2156        return false;
2157
2158    if (!record_decl->field_empty())
2159        return true;
2160
2161    // No fields, lets check this is a CXX record and check the base classes
2162    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2163    if (cxx_record_decl)
2164    {
2165        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2166        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2167             base_class != base_class_end;
2168             ++base_class)
2169        {
2170            const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2171            if (RecordHasFields(base_class_decl))
2172                return true;
2173        }
2174    }
2175    return false;
2176}
2177
2178void
2179ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_type, int default_accessibility, int *assigned_accessibilities, size_t num_assigned_accessibilities)
2180{
2181    if (clang_type)
2182    {
2183        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
2184
2185        const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
2186        if (record_type)
2187        {
2188            RecordDecl *record_decl = record_type->getDecl();
2189            if (record_decl)
2190            {
2191                uint32_t field_idx;
2192                RecordDecl::field_iterator field, field_end;
2193                for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
2194                     field != field_end;
2195                     ++field, ++field_idx)
2196                {
2197                    // If no accessibility was assigned, assign the correct one
2198                    if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
2199                        field->setAccess ((AccessSpecifier)default_accessibility);
2200                }
2201            }
2202        }
2203    }
2204}
2205
2206#pragma mark C++ Base Classes
2207
2208CXXBaseSpecifier *
2209ClangASTContext::CreateBaseClassSpecifier (clang_type_t base_class_type, AccessType access, bool is_virtual, bool base_of_class)
2210{
2211    if (base_class_type)
2212        return new CXXBaseSpecifier (SourceRange(),
2213                                     is_virtual,
2214                                     base_of_class,
2215                                     ConvertAccessTypeToAccessSpecifier (access),
2216                                     getASTContext()->CreateTypeSourceInfo (QualType::getFromOpaquePtr(base_class_type)),
2217                                     SourceLocation());
2218    return NULL;
2219}
2220
2221void
2222ClangASTContext::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
2223{
2224    for (unsigned i=0; i<num_base_classes; ++i)
2225    {
2226        delete base_classes[i];
2227        base_classes[i] = NULL;
2228    }
2229}
2230
2231bool
2232ClangASTContext::SetBaseClassesForClassType (clang_type_t class_clang_type, CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes)
2233{
2234    if (class_clang_type)
2235    {
2236        CXXRecordDecl *cxx_record_decl = QualType::getFromOpaquePtr(class_clang_type)->getAsCXXRecordDecl();
2237        if (cxx_record_decl)
2238        {
2239            cxx_record_decl->setBases(base_classes, num_base_classes);
2240            return true;
2241        }
2242    }
2243    return false;
2244}
2245#pragma mark Objective C Classes
2246
2247clang_type_t
2248ClangASTContext::CreateObjCClass
2249(
2250    const char *name,
2251    DeclContext *decl_ctx,
2252    bool isForwardDecl,
2253    bool isInternal
2254)
2255{
2256    ASTContext *ast = getASTContext();
2257    assert (ast != NULL);
2258    assert (name && name[0]);
2259    if (decl_ctx == NULL)
2260        decl_ctx = ast->getTranslationUnitDecl();
2261
2262    // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
2263    // we will need to update this code. I was told to currently always use
2264    // the CXXRecordDecl class since we often don't know from debug information
2265    // if something is struct or a class, so we default to always use the more
2266    // complete definition just in case.
2267    ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
2268                                                         decl_ctx,
2269                                                         SourceLocation(),
2270                                                         &ast->Idents.get(name),
2271                                                         NULL,
2272                                                         SourceLocation(),
2273                                                         /*isForwardDecl,*/
2274                                                         isInternal);
2275
2276    return ast->getObjCInterfaceType(decl).getAsOpaquePtr();
2277}
2278
2279bool
2280ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t super_opaque_type)
2281{
2282    if (class_opaque_type && super_opaque_type)
2283    {
2284        QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
2285        QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type));
2286        const clang::Type *class_type = class_qual_type.getTypePtr();
2287        const clang::Type *super_type = super_qual_type.getTypePtr();
2288        if (class_type && super_type)
2289        {
2290            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
2291            const ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
2292            if (objc_class_type && objc_super_type)
2293            {
2294                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2295                ObjCInterfaceDecl *super_interface_decl = objc_super_type->getInterface();
2296                if (class_interface_decl && super_interface_decl)
2297                {
2298                    class_interface_decl->setSuperClass(super_interface_decl);
2299                    return true;
2300                }
2301            }
2302        }
2303    }
2304    return false;
2305}
2306
2307
2308FieldDecl *
2309ClangASTContext::AddObjCClassIVar
2310(
2311    ASTContext *ast,
2312    clang_type_t class_opaque_type,
2313    const char *name,
2314    clang_type_t ivar_opaque_type,
2315    AccessType access,
2316    uint32_t bitfield_bit_size,
2317    bool is_synthesized
2318)
2319{
2320    if (class_opaque_type == NULL || ivar_opaque_type == NULL)
2321        return NULL;
2322
2323    ObjCIvarDecl *field = NULL;
2324
2325    IdentifierTable *identifier_table = &ast->Idents;
2326
2327    assert (ast != NULL);
2328    assert (identifier_table != NULL);
2329
2330    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
2331
2332    const clang::Type *class_type = class_qual_type.getTypePtr();
2333    if (class_type)
2334    {
2335        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
2336
2337        if (objc_class_type)
2338        {
2339            ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2340
2341            if (class_interface_decl)
2342            {
2343                clang::Expr *bit_width = NULL;
2344                if (bitfield_bit_size != 0)
2345                {
2346                    APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
2347                    bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
2348                }
2349
2350                field = ObjCIvarDecl::Create (*ast,
2351                                              class_interface_decl,
2352                                              SourceLocation(),
2353                                              SourceLocation(),
2354                                              &identifier_table->get(name), // Identifier
2355                                              QualType::getFromOpaquePtr(ivar_opaque_type), // Field type
2356                                              NULL, // TypeSourceInfo *
2357                                              ConvertAccessTypeToObjCIvarAccessControl (access),
2358                                              bit_width,
2359                                              is_synthesized);
2360
2361                if (field)
2362                {
2363                    class_interface_decl->addDecl(field);
2364
2365#ifdef LLDB_CONFIGURATION_DEBUG
2366                    VerifyDecl(field);
2367#endif
2368
2369                    return field;
2370                }
2371            }
2372        }
2373    }
2374    return NULL;
2375}
2376
2377bool
2378ClangASTContext::AddObjCClassProperty
2379(
2380    ASTContext *ast,
2381    clang_type_t class_opaque_type,
2382    const char *property_name,
2383    clang_type_t property_opaque_type,
2384    ObjCIvarDecl *ivar_decl,
2385    const char *property_setter_name,
2386    const char *property_getter_name,
2387    uint32_t property_attributes
2388)
2389{
2390    if (class_opaque_type == NULL || property_name == NULL || property_name[0] == '\0')
2391        return false;
2392
2393    IdentifierTable *identifier_table = &ast->Idents;
2394
2395    assert (ast != NULL);
2396    assert (identifier_table != NULL);
2397
2398    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
2399    const clang::Type *class_type = class_qual_type.getTypePtr();
2400    if (class_type)
2401    {
2402        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
2403
2404        if (objc_class_type)
2405        {
2406            ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2407
2408            clang_type_t property_opaque_type_to_access;
2409
2410            if (property_opaque_type)
2411                property_opaque_type_to_access = property_opaque_type;
2412            else if (ivar_decl)
2413                property_opaque_type_to_access = ivar_decl->getType().getAsOpaquePtr();
2414
2415            if (class_interface_decl && property_opaque_type_to_access)
2416            {
2417                clang::TypeSourceInfo *prop_type_source;
2418                if (ivar_decl)
2419                    prop_type_source = ast->CreateTypeSourceInfo (ivar_decl->getType());
2420                else
2421                    prop_type_source = ast->CreateTypeSourceInfo (QualType::getFromOpaquePtr(property_opaque_type));
2422
2423                ObjCPropertyDecl *property_decl = ObjCPropertyDecl::Create(*ast,
2424                                                                           class_interface_decl,
2425                                                                           SourceLocation(), // Source Location
2426                                                                           &identifier_table->get(property_name),
2427                                                                           SourceLocation(), //Source Location for AT
2428                                                                           SourceLocation(), //Source location for (
2429                                                                           prop_type_source
2430                                                                           );
2431                if (property_decl)
2432                {
2433                    class_interface_decl->addDecl (property_decl);
2434
2435                    Selector setter_sel, getter_sel;
2436
2437                    if (property_setter_name != NULL)
2438                    {
2439                        std::string property_setter_no_colon(property_setter_name, strlen(property_setter_name) - 1);
2440                        clang::IdentifierInfo *setter_ident = &identifier_table->get(property_setter_no_colon.c_str());
2441                        setter_sel = ast->Selectors.getSelector(1, &setter_ident);
2442                    }
2443                    else if (!(property_attributes & DW_APPLE_PROPERTY_readonly))
2444                    {
2445                        std::string setter_sel_string("set");
2446                        setter_sel_string.push_back(::toupper(property_name[0]));
2447                        setter_sel_string.append(&property_name[1]);
2448                        clang::IdentifierInfo *setter_ident = &identifier_table->get(setter_sel_string.c_str());
2449                        setter_sel = ast->Selectors.getSelector(1, &setter_ident);
2450                    }
2451                    property_decl->setSetterName(setter_sel);
2452                    property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_setter);
2453
2454                    if (property_getter_name != NULL)
2455                    {
2456                        clang::IdentifierInfo *getter_ident = &identifier_table->get(property_getter_name);
2457                        getter_sel = ast->Selectors.getSelector(0, &getter_ident);
2458                    }
2459                    else
2460                    {
2461                        clang::IdentifierInfo *getter_ident = &identifier_table->get(property_name);
2462                        getter_sel = ast->Selectors.getSelector(0, &getter_ident);
2463                    }
2464                    property_decl->setGetterName(getter_sel);
2465                    property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_getter);
2466
2467                    if (ivar_decl)
2468                        property_decl->setPropertyIvarDecl (ivar_decl);
2469
2470                    if (property_attributes & DW_APPLE_PROPERTY_readonly)
2471                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readonly);
2472                    if (property_attributes & DW_APPLE_PROPERTY_readwrite)
2473                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_readwrite);
2474                    if (property_attributes & DW_APPLE_PROPERTY_assign)
2475                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_assign);
2476                    if (property_attributes & DW_APPLE_PROPERTY_retain)
2477                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_retain);
2478                    if (property_attributes & DW_APPLE_PROPERTY_copy)
2479                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_copy);
2480                    if (property_attributes & DW_APPLE_PROPERTY_nonatomic)
2481                        property_decl->setPropertyAttributes (clang::ObjCPropertyDecl::OBJC_PR_nonatomic);
2482
2483                    if (!getter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(getter_sel))
2484                    {
2485                        QualType result_type = QualType::getFromOpaquePtr(property_opaque_type_to_access);
2486
2487                        const bool isInstance = true;
2488                        const bool isVariadic = false;
2489                        const bool isSynthesized = false;
2490                        const bool isImplicitlyDeclared = true;
2491                        const bool isDefined = false;
2492                        const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
2493                        const bool HasRelatedResultType = false;
2494
2495                        ObjCMethodDecl *getter = ObjCMethodDecl::Create(*ast,
2496                                                                        SourceLocation(),
2497                                                                        SourceLocation(),
2498                                                                        getter_sel,
2499                                                                        result_type,
2500                                                                        NULL,
2501                                                                        class_interface_decl,
2502                                                                        isInstance,
2503                                                                        isVariadic,
2504                                                                        isSynthesized,
2505                                                                        isImplicitlyDeclared,
2506                                                                        isDefined,
2507                                                                        impControl,
2508                                                                        HasRelatedResultType);
2509
2510                        getter->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(), ArrayRef<SourceLocation>());
2511
2512                        class_interface_decl->addDecl(getter);
2513                    }
2514
2515                    if (!setter_sel.isNull() && !class_interface_decl->lookupInstanceMethod(setter_sel))
2516                    {
2517                        QualType result_type = ast->VoidTy;
2518
2519                        const bool isInstance = true;
2520                        const bool isVariadic = false;
2521                        const bool isSynthesized = false;
2522                        const bool isImplicitlyDeclared = true;
2523                        const bool isDefined = false;
2524                        const ObjCMethodDecl::ImplementationControl impControl = ObjCMethodDecl::None;
2525                        const bool HasRelatedResultType = false;
2526
2527                        ObjCMethodDecl *setter = ObjCMethodDecl::Create(*ast,
2528                                                                        SourceLocation(),
2529                                                                        SourceLocation(),
2530                                                                        setter_sel,
2531                                                                        result_type,
2532                                                                        NULL,
2533                                                                        class_interface_decl,
2534                                                                        isInstance,
2535                                                                        isVariadic,
2536                                                                        isSynthesized,
2537                                                                        isImplicitlyDeclared,
2538                                                                        isDefined,
2539                                                                        impControl,
2540                                                                        HasRelatedResultType);
2541
2542                        llvm::SmallVector<ParmVarDecl *, 1> params;
2543
2544                        params.push_back (ParmVarDecl::Create (*ast,
2545                                                               setter,
2546                                                               SourceLocation(),
2547                                                               SourceLocation(),
2548                                                               NULL, // anonymous
2549                                                               QualType::getFromOpaquePtr(property_opaque_type_to_access),
2550                                                               NULL,
2551                                                               SC_Auto,
2552                                                               SC_Auto,
2553                                                               NULL));
2554
2555                        setter->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
2556
2557                        class_interface_decl->addDecl(setter);
2558                    }
2559
2560                    return true;
2561                }
2562            }
2563        }
2564    }
2565    return false;
2566}
2567
2568bool
2569ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_superclass)
2570{
2571    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
2572
2573    const clang::Type *class_type = class_qual_type.getTypePtr();
2574    if (class_type)
2575    {
2576        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
2577
2578        if (objc_class_type)
2579            return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass);
2580    }
2581    return false;
2582}
2583
2584bool
2585ClangASTContext::ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
2586{
2587    while (class_interface_decl)
2588    {
2589        if (class_interface_decl->ivar_size() > 0)
2590            return true;
2591
2592        if (check_superclass)
2593            class_interface_decl = class_interface_decl->getSuperClass();
2594        else
2595            break;
2596    }
2597    return false;
2598}
2599
2600ObjCMethodDecl *
2601ClangASTContext::AddMethodToObjCObjectType
2602(
2603    ASTContext *ast,
2604    clang_type_t class_opaque_type,
2605    const char *name,  // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
2606    clang_type_t method_opaque_type,
2607    lldb::AccessType access
2608)
2609{
2610    if (class_opaque_type == NULL || method_opaque_type == NULL)
2611        return NULL;
2612
2613    IdentifierTable *identifier_table = &ast->Idents;
2614
2615    assert (ast != NULL);
2616    assert (identifier_table != NULL);
2617
2618    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
2619
2620    const clang::Type *class_type = class_qual_type.getTypePtr();
2621    if (class_type == NULL)
2622        return NULL;
2623
2624    const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
2625
2626    if (objc_class_type == NULL)
2627        return NULL;
2628
2629    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2630
2631    if (class_interface_decl == NULL)
2632        return NULL;
2633
2634    const char *selector_start = ::strchr (name, ' ');
2635    if (selector_start == NULL)
2636        return NULL;
2637
2638    selector_start++;
2639    if (!(::isalpha (selector_start[0]) || selector_start[0] == '_'))
2640        return NULL;
2641    llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
2642
2643    size_t len = 0;
2644    const char *start;
2645    //printf ("name = '%s'\n", name);
2646
2647    unsigned num_selectors_with_args = 0;
2648    for (start = selector_start;
2649         start && *start != '\0' && *start != ']';
2650         start += len)
2651    {
2652        len = ::strcspn(start, ":]");
2653        bool has_arg = (start[len] == ':');
2654        if (has_arg)
2655            ++num_selectors_with_args;
2656        selector_idents.push_back (&identifier_table->get (StringRef (start, len)));
2657        if (has_arg)
2658            len += 1;
2659    }
2660
2661
2662    if (selector_idents.size() == 0)
2663        return 0;
2664
2665    clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
2666                                                                          selector_idents.data());
2667
2668    QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
2669
2670    // Populate the method decl with parameter decls
2671    const clang::Type *method_type(method_qual_type.getTypePtr());
2672
2673    if (method_type == NULL)
2674        return NULL;
2675
2676    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
2677
2678    if (!method_function_prototype)
2679        return NULL;
2680
2681
2682    bool is_variadic = false;
2683    bool is_synthesized = false;
2684    bool is_defined = false;
2685    ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
2686
2687    const unsigned num_args = method_function_prototype->getNumArgs();
2688
2689    ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*ast,
2690                                                               SourceLocation(), // beginLoc,
2691                                                               SourceLocation(), // endLoc,
2692                                                               method_selector,
2693                                                               method_function_prototype->getResultType(),
2694                                                               NULL, // TypeSourceInfo *ResultTInfo,
2695                                                               GetDeclContextForType (class_opaque_type),
2696                                                               name[0] == '-',
2697                                                               is_variadic,
2698                                                               is_synthesized,
2699                                                               true, // is_implicitly_declared
2700                                                               is_defined,
2701                                                               imp_control,
2702                                                               false /*has_related_result_type*/);
2703
2704
2705    if (objc_method_decl == NULL)
2706        return NULL;
2707
2708    if (num_args > 0)
2709    {
2710        llvm::SmallVector<ParmVarDecl *, 12> params;
2711
2712        for (int param_index = 0; param_index < num_args; ++param_index)
2713        {
2714            params.push_back (ParmVarDecl::Create (*ast,
2715                                                   objc_method_decl,
2716                                                   SourceLocation(),
2717                                                   SourceLocation(),
2718                                                   NULL, // anonymous
2719                                                   method_function_prototype->getArgType(param_index),
2720                                                   NULL,
2721                                                   SC_Auto,
2722                                                   SC_Auto,
2723                                                   NULL));
2724        }
2725
2726        objc_method_decl->setMethodParams(*ast, ArrayRef<ParmVarDecl*>(params), ArrayRef<SourceLocation>());
2727    }
2728
2729    class_interface_decl->addDecl (objc_method_decl);
2730
2731#ifdef LLDB_CONFIGURATION_DEBUG
2732    VerifyDecl(objc_method_decl);
2733#endif
2734
2735    return objc_method_decl;
2736}
2737
2738size_t
2739ClangASTContext::GetNumTemplateArguments (clang::ASTContext *ast, clang_type_t clang_type)
2740{
2741    if (clang_type)
2742    {
2743        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2744
2745        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2746        switch (type_class)
2747        {
2748            case clang::Type::Record:
2749                if (GetCompleteQualType (ast, qual_type))
2750                {
2751                    const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2752                    if (cxx_record_decl)
2753                    {
2754                        const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
2755                        if (template_decl)
2756                            return template_decl->getTemplateArgs().size();
2757                    }
2758                }
2759                break;
2760
2761            case clang::Type::Typedef:
2762                return ClangASTContext::GetNumTemplateArguments (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2763            default:
2764                break;
2765        }
2766    }
2767    return 0;
2768}
2769
2770clang_type_t
2771ClangASTContext::GetTemplateArgument (clang::ASTContext *ast, clang_type_t clang_type, size_t arg_idx, lldb::TemplateArgumentKind &kind)
2772{
2773    if (clang_type)
2774    {
2775        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2776
2777        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2778        switch (type_class)
2779        {
2780            case clang::Type::Record:
2781                if (GetCompleteQualType (ast, qual_type))
2782                {
2783                    const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
2784                    if (cxx_record_decl)
2785                    {
2786                        const ClassTemplateSpecializationDecl *template_decl = dyn_cast<ClassTemplateSpecializationDecl>(cxx_record_decl);
2787                        if (template_decl && arg_idx < template_decl->getTemplateArgs().size())
2788                        {
2789                            const TemplateArgument &template_arg = template_decl->getTemplateArgs()[arg_idx];
2790                            switch (template_arg.getKind())
2791                            {
2792                                case clang::TemplateArgument::Null:
2793                                    kind = eTemplateArgumentKindNull;
2794                                    return NULL;
2795
2796                                case clang::TemplateArgument::Type:
2797                                    kind = eTemplateArgumentKindType;
2798                                    return template_arg.getAsType().getAsOpaquePtr();
2799
2800                                case clang::TemplateArgument::Declaration:
2801                                    kind = eTemplateArgumentKindDeclaration;
2802                                    return NULL;
2803
2804                                case clang::TemplateArgument::Integral:
2805                                    kind = eTemplateArgumentKindIntegral;
2806                                    return template_arg.getIntegralType().getAsOpaquePtr();
2807
2808                                case clang::TemplateArgument::Template:
2809                                    kind = eTemplateArgumentKindTemplate;
2810                                    return NULL;
2811
2812                                case clang::TemplateArgument::TemplateExpansion:
2813                                    kind = eTemplateArgumentKindTemplateExpansion;
2814                                    return NULL;
2815
2816                                case clang::TemplateArgument::Expression:
2817                                    kind = eTemplateArgumentKindExpression;
2818                                    return NULL;
2819
2820                                case clang::TemplateArgument::Pack:
2821                                    kind = eTemplateArgumentKindPack;
2822                                    return NULL;
2823
2824                                default:
2825                                    assert (!"Unhandled TemplateArgument::ArgKind");
2826                                    kind = eTemplateArgumentKindNull;
2827                                    return NULL;
2828                            }
2829                        }
2830                    }
2831                }
2832                break;
2833
2834            case clang::Type::Typedef:
2835                return ClangASTContext::GetTemplateArgument (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), arg_idx, kind);
2836            default:
2837                break;
2838        }
2839    }
2840    kind = eTemplateArgumentKindNull;
2841    return NULL;
2842}
2843
2844uint32_t
2845ClangASTContext::GetTypeInfo
2846(
2847    clang_type_t clang_type,
2848    clang::ASTContext *ast,
2849    clang_type_t *pointee_or_element_clang_type
2850)
2851{
2852    if (clang_type == NULL)
2853        return 0;
2854
2855    if (pointee_or_element_clang_type)
2856        *pointee_or_element_clang_type = NULL;
2857
2858    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2859
2860    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2861    switch (type_class)
2862    {
2863    case clang::Type::Builtin:
2864        switch (cast<clang::BuiltinType>(qual_type)->getKind())
2865        {
2866        case clang::BuiltinType::ObjCId:
2867        case clang::BuiltinType::ObjCClass:
2868            if (ast && pointee_or_element_clang_type)
2869                *pointee_or_element_clang_type = ast->ObjCBuiltinClassTy.getAsOpaquePtr();
2870            return eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue;
2871                break;
2872        case clang::BuiltinType::Bool:
2873        case clang::BuiltinType::Char_U:
2874        case clang::BuiltinType::UChar:
2875        case clang::BuiltinType::WChar_U:
2876        case clang::BuiltinType::Char16:
2877        case clang::BuiltinType::Char32:
2878        case clang::BuiltinType::UShort:
2879        case clang::BuiltinType::UInt:
2880        case clang::BuiltinType::ULong:
2881        case clang::BuiltinType::ULongLong:
2882        case clang::BuiltinType::UInt128:
2883        case clang::BuiltinType::Char_S:
2884        case clang::BuiltinType::SChar:
2885        case clang::BuiltinType::WChar_S:
2886        case clang::BuiltinType::Short:
2887        case clang::BuiltinType::Int:
2888        case clang::BuiltinType::Long:
2889        case clang::BuiltinType::LongLong:
2890        case clang::BuiltinType::Int128:
2891        case clang::BuiltinType::Float:
2892        case clang::BuiltinType::Double:
2893        case clang::BuiltinType::LongDouble:
2894                return eTypeIsBuiltIn | eTypeHasValue | eTypeIsScalar;
2895        default:
2896            break;
2897        }
2898        return eTypeIsBuiltIn | eTypeHasValue;
2899
2900    case clang::Type::BlockPointer:
2901        if (pointee_or_element_clang_type)
2902            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2903        return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
2904
2905    case clang::Type::Complex:                          return eTypeIsBuiltIn | eTypeHasValue;
2906
2907    case clang::Type::ConstantArray:
2908    case clang::Type::DependentSizedArray:
2909    case clang::Type::IncompleteArray:
2910    case clang::Type::VariableArray:
2911        if (pointee_or_element_clang_type)
2912            *pointee_or_element_clang_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
2913        return eTypeHasChildren | eTypeIsArray;
2914
2915    case clang::Type::DependentName:                    return 0;
2916    case clang::Type::DependentSizedExtVector:          return eTypeHasChildren | eTypeIsVector;
2917    case clang::Type::DependentTemplateSpecialization:  return eTypeIsTemplate;
2918    case clang::Type::Decltype:                         return 0;
2919
2920    case clang::Type::Enum:
2921        if (pointee_or_element_clang_type)
2922            *pointee_or_element_clang_type = cast<EnumType>(qual_type)->getDecl()->getIntegerType().getAsOpaquePtr();
2923        return eTypeIsEnumeration | eTypeHasValue;
2924
2925    case clang::Type::Elaborated:
2926        return ClangASTContext::GetTypeInfo (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
2927                                             ast,
2928                                             pointee_or_element_clang_type);
2929    case clang::Type::ExtVector:                        return eTypeHasChildren | eTypeIsVector;
2930    case clang::Type::FunctionProto:                    return eTypeIsFuncPrototype | eTypeHasValue;
2931    case clang::Type::FunctionNoProto:                  return eTypeIsFuncPrototype | eTypeHasValue;
2932    case clang::Type::InjectedClassName:                return 0;
2933
2934    case clang::Type::LValueReference:
2935    case clang::Type::RValueReference:
2936        if (pointee_or_element_clang_type)
2937            *pointee_or_element_clang_type = cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr();
2938        return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
2939
2940    case clang::Type::MemberPointer:                    return eTypeIsPointer   | eTypeIsMember | eTypeHasValue;
2941
2942    case clang::Type::ObjCObjectPointer:
2943        if (pointee_or_element_clang_type)
2944            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2945        return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
2946
2947    case clang::Type::ObjCObject:                       return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
2948    case clang::Type::ObjCInterface:                    return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
2949
2950    case clang::Type::Pointer:
2951        if (pointee_or_element_clang_type)
2952            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2953        return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
2954
2955    case clang::Type::Record:
2956        if (qual_type->getAsCXXRecordDecl())
2957            return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
2958        else
2959            return eTypeHasChildren | eTypeIsStructUnion;
2960        break;
2961    case clang::Type::SubstTemplateTypeParm:            return eTypeIsTemplate;
2962    case clang::Type::TemplateTypeParm:                 return eTypeIsTemplate;
2963    case clang::Type::TemplateSpecialization:           return eTypeIsTemplate;
2964
2965    case clang::Type::Typedef:
2966        return eTypeIsTypedef | ClangASTContext::GetTypeInfo (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2967                                                                  ast,
2968                                                                  pointee_or_element_clang_type);
2969
2970    case clang::Type::TypeOfExpr:                       return 0;
2971    case clang::Type::TypeOf:                           return 0;
2972    case clang::Type::UnresolvedUsing:                  return 0;
2973    case clang::Type::Vector:                           return eTypeHasChildren | eTypeIsVector;
2974    default:                                            return 0;
2975    }
2976    return 0;
2977}
2978
2979
2980#pragma mark Aggregate Types
2981
2982bool
2983ClangASTContext::IsAggregateType (clang_type_t clang_type)
2984{
2985    if (clang_type == NULL)
2986        return false;
2987
2988    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2989
2990    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2991    switch (type_class)
2992    {
2993    case clang::Type::IncompleteArray:
2994    case clang::Type::VariableArray:
2995    case clang::Type::ConstantArray:
2996    case clang::Type::ExtVector:
2997    case clang::Type::Vector:
2998    case clang::Type::Record:
2999    case clang::Type::ObjCObject:
3000    case clang::Type::ObjCInterface:
3001        return true;
3002    case clang::Type::Elaborated:
3003        return ClangASTContext::IsAggregateType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3004    case clang::Type::Typedef:
3005        return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3006
3007    default:
3008        break;
3009    }
3010    // The clang type does have a value
3011    return false;
3012}
3013
3014uint32_t
3015ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type, bool omit_empty_base_classes)
3016{
3017    if (clang_type == NULL)
3018        return 0;
3019
3020    uint32_t num_children = 0;
3021    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3022    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3023    switch (type_class)
3024    {
3025    case clang::Type::Builtin:
3026        switch (cast<clang::BuiltinType>(qual_type)->getKind())
3027        {
3028        case clang::BuiltinType::ObjCId:    // child is Class
3029        case clang::BuiltinType::ObjCClass: // child is Class
3030            num_children = 1;
3031            break;
3032
3033        default:
3034            break;
3035        }
3036        break;
3037
3038    case clang::Type::Complex: return 0;
3039
3040    case clang::Type::Record:
3041        if (GetCompleteQualType (ast, qual_type))
3042        {
3043            const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3044            const RecordDecl *record_decl = record_type->getDecl();
3045            assert(record_decl);
3046            const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3047            if (cxx_record_decl)
3048            {
3049                if (omit_empty_base_classes)
3050                {
3051                    // Check each base classes to see if it or any of its
3052                    // base classes contain any fields. This can help
3053                    // limit the noise in variable views by not having to
3054                    // show base classes that contain no members.
3055                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3056                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3057                         base_class != base_class_end;
3058                         ++base_class)
3059                    {
3060                        const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3061
3062                        // Skip empty base classes
3063                        if (RecordHasFields(base_class_decl) == false)
3064                            continue;
3065
3066                        num_children++;
3067                    }
3068                }
3069                else
3070                {
3071                    // Include all base classes
3072                    num_children += cxx_record_decl->getNumBases();
3073                }
3074
3075            }
3076            RecordDecl::field_iterator field, field_end;
3077            for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
3078                ++num_children;
3079        }
3080        break;
3081
3082    case clang::Type::ObjCObject:
3083    case clang::Type::ObjCInterface:
3084        if (GetCompleteQualType (ast, qual_type))
3085        {
3086            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3087            assert (objc_class_type);
3088            if (objc_class_type)
3089            {
3090                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3091
3092                if (class_interface_decl)
3093                {
3094
3095                    ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3096                    if (superclass_interface_decl)
3097                    {
3098                        if (omit_empty_base_classes)
3099                        {
3100                            if (ClangASTContext::ObjCDeclHasIVars (superclass_interface_decl, true))
3101                                ++num_children;
3102                        }
3103                        else
3104                            ++num_children;
3105                    }
3106
3107                    num_children += class_interface_decl->ivar_size();
3108                }
3109            }
3110        }
3111        break;
3112
3113    case clang::Type::ObjCObjectPointer:
3114        {
3115            const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
3116            QualType pointee_type = pointer_type->getPointeeType();
3117            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
3118                                                                             pointee_type.getAsOpaquePtr(),
3119                                                                             omit_empty_base_classes);
3120            // If this type points to a simple type, then it has 1 child
3121            if (num_pointee_children == 0)
3122                num_children = 1;
3123            else
3124                num_children = num_pointee_children;
3125        }
3126        break;
3127
3128    case clang::Type::ConstantArray:
3129        num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
3130        break;
3131
3132    case clang::Type::Pointer:
3133        {
3134            const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3135            QualType pointee_type (pointer_type->getPointeeType());
3136            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
3137                                                                             pointee_type.getAsOpaquePtr(),
3138                                                                             omit_empty_base_classes);
3139            if (num_pointee_children == 0)
3140            {
3141                // We have a pointer to a pointee type that claims it has no children.
3142                // We will want to look at
3143                num_children = ClangASTContext::GetNumPointeeChildren (pointee_type.getAsOpaquePtr());
3144            }
3145            else
3146                num_children = num_pointee_children;
3147        }
3148        break;
3149
3150    case clang::Type::LValueReference:
3151    case clang::Type::RValueReference:
3152        {
3153            const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3154            QualType pointee_type = reference_type->getPointeeType();
3155            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
3156                                                                             pointee_type.getAsOpaquePtr(),
3157                                                                             omit_empty_base_classes);
3158            // If this type points to a simple type, then it has 1 child
3159            if (num_pointee_children == 0)
3160                num_children = 1;
3161            else
3162                num_children = num_pointee_children;
3163        }
3164        break;
3165
3166
3167    case clang::Type::Typedef:
3168        num_children = ClangASTContext::GetNumChildren (ast,
3169                                                        cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3170                                                        omit_empty_base_classes);
3171        break;
3172
3173    case clang::Type::Elaborated:
3174        num_children = ClangASTContext::GetNumChildren (ast,
3175                                                        cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
3176                                                        omit_empty_base_classes);
3177        break;
3178
3179    default:
3180        break;
3181    }
3182    return num_children;
3183}
3184
3185uint32_t
3186ClangASTContext::GetNumDirectBaseClasses (clang::ASTContext *ast, clang_type_t clang_type)
3187{
3188    if (clang_type == NULL)
3189        return 0;
3190
3191    uint32_t count = 0;
3192    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3193    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3194    switch (type_class)
3195    {
3196        case clang::Type::Record:
3197            if (GetCompleteQualType (ast, qual_type))
3198            {
3199                const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3200                if (cxx_record_decl)
3201                    count = cxx_record_decl->getNumBases();
3202            }
3203            break;
3204
3205        case clang::Type::ObjCObject:
3206        case clang::Type::ObjCInterface:
3207            if (GetCompleteQualType (ast, qual_type))
3208            {
3209                const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
3210                if (objc_class_type)
3211                {
3212                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3213
3214                    if (class_interface_decl && class_interface_decl->getSuperClass())
3215                        count = 1;
3216                }
3217            }
3218            break;
3219
3220
3221        case clang::Type::Typedef:
3222            count = ClangASTContext::GetNumDirectBaseClasses (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3223            break;
3224
3225        case clang::Type::Elaborated:
3226            count = ClangASTContext::GetNumDirectBaseClasses (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3227            break;
3228
3229        default:
3230            break;
3231    }
3232    return count;
3233}
3234
3235uint32_t
3236ClangASTContext::GetNumVirtualBaseClasses (clang::ASTContext *ast,
3237                                           clang_type_t clang_type)
3238{
3239    if (clang_type == NULL)
3240        return 0;
3241
3242    uint32_t count = 0;
3243    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3244    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3245    switch (type_class)
3246    {
3247        case clang::Type::Record:
3248            if (GetCompleteQualType (ast, qual_type))
3249            {
3250                const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3251                if (cxx_record_decl)
3252                    count = cxx_record_decl->getNumVBases();
3253            }
3254            break;
3255
3256        case clang::Type::Typedef:
3257            count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3258            break;
3259
3260        case clang::Type::Elaborated:
3261            count = ClangASTContext::GetNumVirtualBaseClasses (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3262            break;
3263
3264        default:
3265            break;
3266    }
3267    return count;
3268}
3269
3270uint32_t
3271ClangASTContext::GetNumFields (clang::ASTContext *ast, clang_type_t clang_type)
3272{
3273    if (clang_type == NULL)
3274        return 0;
3275
3276    uint32_t count = 0;
3277    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3278    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3279    switch (type_class)
3280    {
3281        case clang::Type::Record:
3282            if (GetCompleteQualType (ast, qual_type))
3283            {
3284                const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
3285                if (record_type)
3286                {
3287                    RecordDecl *record_decl = record_type->getDecl();
3288                    if (record_decl)
3289                    {
3290                        uint32_t field_idx = 0;
3291                        RecordDecl::field_iterator field, field_end;
3292                        for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
3293                            ++field_idx;
3294                        count = field_idx;
3295                    }
3296                }
3297            }
3298            break;
3299
3300        case clang::Type::Typedef:
3301            count = ClangASTContext::GetNumFields (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3302            break;
3303
3304        case clang::Type::Elaborated:
3305            count = ClangASTContext::GetNumFields (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3306            break;
3307
3308        case clang::Type::ObjCObject:
3309        case clang::Type::ObjCInterface:
3310            if (GetCompleteQualType (ast, qual_type))
3311            {
3312                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3313                if (objc_class_type)
3314                {
3315                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3316
3317                    if (class_interface_decl)
3318                        count = class_interface_decl->ivar_size();
3319                }
3320            }
3321            break;
3322
3323        default:
3324            break;
3325    }
3326    return count;
3327}
3328
3329clang_type_t
3330ClangASTContext::GetDirectBaseClassAtIndex (clang::ASTContext *ast,
3331                                            clang_type_t clang_type,
3332                                            uint32_t idx,
3333                                            uint32_t *bit_offset_ptr)
3334{
3335    if (clang_type == NULL)
3336        return 0;
3337
3338    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3339    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3340    switch (type_class)
3341    {
3342        case clang::Type::Record:
3343            if (GetCompleteQualType (ast, qual_type))
3344            {
3345                const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3346                if (cxx_record_decl)
3347                {
3348                    uint32_t curr_idx = 0;
3349                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3350                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3351                         base_class != base_class_end;
3352                         ++base_class, ++curr_idx)
3353                    {
3354                        if (curr_idx == idx)
3355                        {
3356                            if (bit_offset_ptr)
3357                            {
3358                                const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl);
3359                                const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3360//                                if (base_class->isVirtual())
3361//                                    *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
3362//                                else
3363                                    *bit_offset_ptr = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
3364                            }
3365                            return base_class->getType().getAsOpaquePtr();
3366                        }
3367                    }
3368                }
3369            }
3370            break;
3371
3372        case clang::Type::ObjCObject:
3373        case clang::Type::ObjCInterface:
3374            if (idx == 0 && GetCompleteQualType (ast, qual_type))
3375            {
3376                const ObjCObjectType *objc_class_type = qual_type->getAsObjCQualifiedInterfaceType();
3377                if (objc_class_type)
3378                {
3379                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3380
3381                    if (class_interface_decl)
3382                    {
3383                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3384                        if (superclass_interface_decl)
3385                        {
3386                            if (bit_offset_ptr)
3387                                *bit_offset_ptr = 0;
3388                            return ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr();
3389                        }
3390                    }
3391                }
3392            }
3393            break;
3394
3395
3396        case clang::Type::Typedef:
3397            return ClangASTContext::GetDirectBaseClassAtIndex (ast,
3398                                                               cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3399                                                               idx,
3400                                                               bit_offset_ptr);
3401
3402        case clang::Type::Elaborated:
3403            return  ClangASTContext::GetDirectBaseClassAtIndex (ast,
3404                                                                cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
3405                                                                idx,
3406                                                                bit_offset_ptr);
3407
3408        default:
3409            break;
3410    }
3411    return NULL;
3412}
3413
3414clang_type_t
3415ClangASTContext::GetVirtualBaseClassAtIndex (clang::ASTContext *ast,
3416                                             clang_type_t clang_type,
3417                                             uint32_t idx,
3418                                             uint32_t *bit_offset_ptr)
3419{
3420    if (clang_type == NULL)
3421        return 0;
3422
3423    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3424    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3425    switch (type_class)
3426    {
3427        case clang::Type::Record:
3428            if (GetCompleteQualType (ast, qual_type))
3429            {
3430                const CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3431                if (cxx_record_decl)
3432                {
3433                    uint32_t curr_idx = 0;
3434                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3435                    for (base_class = cxx_record_decl->vbases_begin(), base_class_end = cxx_record_decl->vbases_end();
3436                         base_class != base_class_end;
3437                         ++base_class, ++curr_idx)
3438                    {
3439                        if (curr_idx == idx)
3440                        {
3441                            if (bit_offset_ptr)
3442                            {
3443                                const ASTRecordLayout &record_layout = ast->getASTRecordLayout(cxx_record_decl);
3444                                const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3445                                *bit_offset_ptr = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
3446
3447                            }
3448                            return base_class->getType().getAsOpaquePtr();
3449                        }
3450                    }
3451                }
3452            }
3453            break;
3454
3455        case clang::Type::Typedef:
3456            return ClangASTContext::GetVirtualBaseClassAtIndex (ast,
3457                                                                cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3458                                                                idx,
3459                                                                bit_offset_ptr);
3460
3461        case clang::Type::Elaborated:
3462            return  ClangASTContext::GetVirtualBaseClassAtIndex (ast,
3463                                                                 cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
3464                                                                 idx,
3465                                                                 bit_offset_ptr);
3466
3467        default:
3468            break;
3469    }
3470    return NULL;
3471}
3472
3473clang_type_t
3474ClangASTContext::GetFieldAtIndex (clang::ASTContext *ast,
3475                                  clang_type_t clang_type,
3476                                  uint32_t idx,
3477                                  std::string& name,
3478                                  uint32_t *bit_offset_ptr)
3479{
3480    if (clang_type == NULL)
3481        return 0;
3482
3483    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3484    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3485    switch (type_class)
3486    {
3487        case clang::Type::Record:
3488            if (GetCompleteQualType (ast, qual_type))
3489            {
3490                const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3491                const RecordDecl *record_decl = record_type->getDecl();
3492                uint32_t field_idx = 0;
3493                RecordDecl::field_iterator field, field_end;
3494                for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx)
3495                {
3496                    if (idx == field_idx)
3497                    {
3498                        // Print the member type if requested
3499                        // Print the member name and equal sign
3500                        name.assign(field->getNameAsString());
3501
3502                        // Figure out the type byte size (field_type_info.first) and
3503                        // alignment (field_type_info.second) from the AST context.
3504                        if (bit_offset_ptr)
3505                        {
3506                            const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl);
3507                            *bit_offset_ptr = record_layout.getFieldOffset (field_idx);
3508                        }
3509
3510                        return field->getType().getAsOpaquePtr();
3511                    }
3512                }
3513            }
3514            break;
3515
3516        case clang::Type::ObjCObject:
3517        case clang::Type::ObjCInterface:
3518            if (GetCompleteQualType (ast, qual_type))
3519            {
3520                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3521                assert (objc_class_type);
3522                if (objc_class_type)
3523                {
3524                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3525
3526                    if (class_interface_decl)
3527                    {
3528                        if (idx < (class_interface_decl->ivar_size()))
3529                        {
3530                            ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3531                            uint32_t ivar_idx = 0;
3532
3533                            for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++ivar_idx)
3534                            {
3535                                if (ivar_idx == idx)
3536                                {
3537                                    const ObjCIvarDecl* ivar_decl = *ivar_pos;
3538
3539                                    QualType ivar_qual_type(ivar_decl->getType());
3540
3541                                    name.assign(ivar_decl->getNameAsString());
3542
3543                                    if (bit_offset_ptr)
3544                                    {
3545                                        const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
3546                                        *bit_offset_ptr = interface_layout.getFieldOffset (ivar_idx);
3547                                    }
3548
3549                                    return ivar_qual_type.getAsOpaquePtr();
3550                                }
3551                            }
3552                        }
3553                    }
3554                }
3555            }
3556            break;
3557
3558
3559        case clang::Type::Typedef:
3560            return ClangASTContext::GetFieldAtIndex (ast,
3561                                                     cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3562                                                     idx,
3563                                                     name,
3564                                                     bit_offset_ptr);
3565
3566        case clang::Type::Elaborated:
3567            return  ClangASTContext::GetFieldAtIndex (ast,
3568                                                      cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
3569                                                      idx,
3570                                                      name,
3571                                                      bit_offset_ptr);
3572
3573        default:
3574            break;
3575    }
3576    return NULL;
3577}
3578
3579
3580// If a pointer to a pointee type (the clang_type arg) says that it has no
3581// children, then we either need to trust it, or override it and return a
3582// different result. For example, an "int *" has one child that is an integer,
3583// but a function pointer doesn't have any children. Likewise if a Record type
3584// claims it has no children, then there really is nothing to show.
3585uint32_t
3586ClangASTContext::GetNumPointeeChildren (clang_type_t clang_type)
3587{
3588    if (clang_type == NULL)
3589        return 0;
3590
3591    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3592    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3593    switch (type_class)
3594    {
3595    case clang::Type::Builtin:
3596        switch (cast<clang::BuiltinType>(qual_type)->getKind())
3597        {
3598        case clang::BuiltinType::UnknownAny:
3599        case clang::BuiltinType::Void:
3600        case clang::BuiltinType::NullPtr:
3601            return 0;
3602        case clang::BuiltinType::Bool:
3603        case clang::BuiltinType::Char_U:
3604        case clang::BuiltinType::UChar:
3605        case clang::BuiltinType::WChar_U:
3606        case clang::BuiltinType::Char16:
3607        case clang::BuiltinType::Char32:
3608        case clang::BuiltinType::UShort:
3609        case clang::BuiltinType::UInt:
3610        case clang::BuiltinType::ULong:
3611        case clang::BuiltinType::ULongLong:
3612        case clang::BuiltinType::UInt128:
3613        case clang::BuiltinType::Char_S:
3614        case clang::BuiltinType::SChar:
3615        case clang::BuiltinType::WChar_S:
3616        case clang::BuiltinType::Short:
3617        case clang::BuiltinType::Int:
3618        case clang::BuiltinType::Long:
3619        case clang::BuiltinType::LongLong:
3620        case clang::BuiltinType::Int128:
3621        case clang::BuiltinType::Float:
3622        case clang::BuiltinType::Double:
3623        case clang::BuiltinType::LongDouble:
3624        case clang::BuiltinType::Dependent:
3625        case clang::BuiltinType::Overload:
3626        case clang::BuiltinType::ObjCId:
3627        case clang::BuiltinType::ObjCClass:
3628        case clang::BuiltinType::ObjCSel:
3629        case clang::BuiltinType::BoundMember:
3630        case clang::BuiltinType::Half:
3631        case clang::BuiltinType::ARCUnbridgedCast:
3632        case clang::BuiltinType::PseudoObject:
3633            return 1;
3634        }
3635        break;
3636
3637    case clang::Type::Complex:                  return 1;
3638    case clang::Type::Pointer:                  return 1;
3639    case clang::Type::BlockPointer:             return 0;   // If block pointers don't have debug info, then no children for them
3640    case clang::Type::LValueReference:          return 1;
3641    case clang::Type::RValueReference:          return 1;
3642    case clang::Type::MemberPointer:            return 0;
3643    case clang::Type::ConstantArray:            return 0;
3644    case clang::Type::IncompleteArray:          return 0;
3645    case clang::Type::VariableArray:            return 0;
3646    case clang::Type::DependentSizedArray:      return 0;
3647    case clang::Type::DependentSizedExtVector:  return 0;
3648    case clang::Type::Vector:                   return 0;
3649    case clang::Type::ExtVector:                return 0;
3650    case clang::Type::FunctionProto:            return 0;   // When we function pointers, they have no children...
3651    case clang::Type::FunctionNoProto:          return 0;   // When we function pointers, they have no children...
3652    case clang::Type::UnresolvedUsing:          return 0;
3653    case clang::Type::Paren:                    return 0;
3654    case clang::Type::Typedef:                  return ClangASTContext::GetNumPointeeChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3655    case clang::Type::Elaborated:               return ClangASTContext::GetNumPointeeChildren (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
3656    case clang::Type::TypeOfExpr:               return 0;
3657    case clang::Type::TypeOf:                   return 0;
3658    case clang::Type::Decltype:                 return 0;
3659    case clang::Type::Record:                   return 0;
3660    case clang::Type::Enum:                     return 1;
3661    case clang::Type::TemplateTypeParm:         return 1;
3662    case clang::Type::SubstTemplateTypeParm:    return 1;
3663    case clang::Type::TemplateSpecialization:   return 1;
3664    case clang::Type::InjectedClassName:        return 0;
3665    case clang::Type::DependentName:            return 1;
3666    case clang::Type::DependentTemplateSpecialization:  return 1;
3667    case clang::Type::ObjCObject:               return 0;
3668    case clang::Type::ObjCInterface:            return 0;
3669    case clang::Type::ObjCObjectPointer:        return 1;
3670    default:
3671        break;
3672    }
3673    return 0;
3674}
3675
3676clang_type_t
3677ClangASTContext::GetChildClangTypeAtIndex
3678(
3679    ExecutionContext *exe_ctx,
3680    const char *parent_name,
3681    clang_type_t parent_clang_type,
3682    uint32_t idx,
3683    bool transparent_pointers,
3684    bool omit_empty_base_classes,
3685    bool ignore_array_bounds,
3686    std::string& child_name,
3687    uint32_t &child_byte_size,
3688    int32_t &child_byte_offset,
3689    uint32_t &child_bitfield_bit_size,
3690    uint32_t &child_bitfield_bit_offset,
3691    bool &child_is_base_class,
3692    bool &child_is_deref_of_parent
3693)
3694{
3695    if (parent_clang_type)
3696
3697        return GetChildClangTypeAtIndex (exe_ctx,
3698                                         getASTContext(),
3699                                         parent_name,
3700                                         parent_clang_type,
3701                                         idx,
3702                                         transparent_pointers,
3703                                         omit_empty_base_classes,
3704                                         ignore_array_bounds,
3705                                         child_name,
3706                                         child_byte_size,
3707                                         child_byte_offset,
3708                                         child_bitfield_bit_size,
3709                                         child_bitfield_bit_offset,
3710                                         child_is_base_class,
3711                                         child_is_deref_of_parent);
3712    return NULL;
3713}
3714
3715clang_type_t
3716ClangASTContext::GetChildClangTypeAtIndex
3717(
3718    ExecutionContext *exe_ctx,
3719    ASTContext *ast,
3720    const char *parent_name,
3721    clang_type_t parent_clang_type,
3722    uint32_t idx,
3723    bool transparent_pointers,
3724    bool omit_empty_base_classes,
3725    bool ignore_array_bounds,
3726    std::string& child_name,
3727    uint32_t &child_byte_size,
3728    int32_t &child_byte_offset,
3729    uint32_t &child_bitfield_bit_size,
3730    uint32_t &child_bitfield_bit_offset,
3731    bool &child_is_base_class,
3732    bool &child_is_deref_of_parent
3733)
3734{
3735    if (parent_clang_type == NULL)
3736        return NULL;
3737
3738    if (idx < ClangASTContext::GetNumChildren (ast, parent_clang_type, omit_empty_base_classes))
3739    {
3740        uint32_t bit_offset;
3741        child_bitfield_bit_size = 0;
3742        child_bitfield_bit_offset = 0;
3743        child_is_base_class = false;
3744        QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type));
3745        const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
3746        switch (parent_type_class)
3747        {
3748        case clang::Type::Builtin:
3749            switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
3750            {
3751            case clang::BuiltinType::ObjCId:
3752            case clang::BuiltinType::ObjCClass:
3753                child_name = "isa";
3754                child_byte_size = ast->getTypeSize(ast->ObjCBuiltinClassTy) / CHAR_BIT;
3755                return ast->ObjCBuiltinClassTy.getAsOpaquePtr();
3756
3757            default:
3758                break;
3759            }
3760            break;
3761
3762        case clang::Type::Record:
3763            if (GetCompleteQualType (ast, parent_qual_type))
3764            {
3765                const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
3766                const RecordDecl *record_decl = record_type->getDecl();
3767                assert(record_decl);
3768                const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl);
3769                uint32_t child_idx = 0;
3770
3771                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3772                if (cxx_record_decl)
3773                {
3774                    // We might have base classes to print out first
3775                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3776                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3777                         base_class != base_class_end;
3778                         ++base_class)
3779                    {
3780                        const CXXRecordDecl *base_class_decl = NULL;
3781
3782                        // Skip empty base classes
3783                        if (omit_empty_base_classes)
3784                        {
3785                            base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3786                            if (RecordHasFields(base_class_decl) == false)
3787                                continue;
3788                        }
3789
3790                        if (idx == child_idx)
3791                        {
3792                            if (base_class_decl == NULL)
3793                                base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3794
3795
3796                            if (base_class->isVirtual())
3797                                bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
3798                            else
3799                                bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
3800
3801                            // Base classes should be a multiple of 8 bits in size
3802                            child_byte_offset = bit_offset/8;
3803
3804                            child_name = ClangASTType::GetTypeNameForQualType(ast, base_class->getType());
3805
3806                            uint64_t clang_type_info_bit_size = ast->getTypeSize(base_class->getType());
3807
3808                            // Base classes bit sizes should be a multiple of 8 bits in size
3809                            assert (clang_type_info_bit_size % 8 == 0);
3810                            child_byte_size = clang_type_info_bit_size / 8;
3811                            child_is_base_class = true;
3812                            return base_class->getType().getAsOpaquePtr();
3813                        }
3814                        // We don't increment the child index in the for loop since we might
3815                        // be skipping empty base classes
3816                        ++child_idx;
3817                    }
3818                }
3819                // Make sure index is in range...
3820                uint32_t field_idx = 0;
3821                RecordDecl::field_iterator field, field_end;
3822                for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
3823                {
3824                    if (idx == child_idx)
3825                    {
3826                        // Print the member type if requested
3827                        // Print the member name and equal sign
3828                        child_name.assign(field->getNameAsString().c_str());
3829
3830                        // Figure out the type byte size (field_type_info.first) and
3831                        // alignment (field_type_info.second) from the AST context.
3832                        std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(field->getType());
3833                        assert(field_idx < record_layout.getFieldCount());
3834
3835                        child_byte_size = field_type_info.first / 8;
3836
3837                        // Figure out the field offset within the current struct/union/class type
3838                        bit_offset = record_layout.getFieldOffset (field_idx);
3839                        child_byte_offset = bit_offset / 8;
3840                        if (ClangASTContext::FieldIsBitfield (ast, *field, child_bitfield_bit_size))
3841                            child_bitfield_bit_offset = bit_offset % 8;
3842
3843                        return field->getType().getAsOpaquePtr();
3844                    }
3845                }
3846            }
3847            break;
3848
3849        case clang::Type::ObjCObject:
3850        case clang::Type::ObjCInterface:
3851            if (GetCompleteQualType (ast, parent_qual_type))
3852            {
3853                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
3854                assert (objc_class_type);
3855                if (objc_class_type)
3856                {
3857                    uint32_t child_idx = 0;
3858                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3859
3860                    if (class_interface_decl)
3861                    {
3862
3863                        const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
3864                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3865                        if (superclass_interface_decl)
3866                        {
3867                            if (omit_empty_base_classes)
3868                            {
3869                                if (ClangASTContext::GetNumChildren(ast, ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), omit_empty_base_classes) > 0)
3870                                {
3871                                    if (idx == 0)
3872                                    {
3873                                        QualType ivar_qual_type(ast->getObjCInterfaceType(superclass_interface_decl));
3874
3875
3876                                        child_name.assign(superclass_interface_decl->getNameAsString().c_str());
3877
3878                                        std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
3879
3880                                        child_byte_size = ivar_type_info.first / 8;
3881                                        child_byte_offset = 0;
3882                                        child_is_base_class = true;
3883
3884                                        return ivar_qual_type.getAsOpaquePtr();
3885                                    }
3886
3887                                    ++child_idx;
3888                                }
3889                            }
3890                            else
3891                                ++child_idx;
3892                        }
3893
3894                        const uint32_t superclass_idx = child_idx;
3895
3896                        if (idx < (child_idx + class_interface_decl->ivar_size()))
3897                        {
3898                            ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3899
3900                            for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3901                            {
3902                                if (child_idx == idx)
3903                                {
3904                                    ObjCIvarDecl* ivar_decl = *ivar_pos;
3905
3906                                    QualType ivar_qual_type(ivar_decl->getType());
3907
3908                                    child_name.assign(ivar_decl->getNameAsString().c_str());
3909
3910                                    std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
3911
3912                                    child_byte_size = ivar_type_info.first / 8;
3913
3914                                    // Figure out the field offset within the current struct/union/class type
3915                                    // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
3916                                    // that doesn't account for the space taken up by unbacked properties, or from
3917                                    // the changing size of base classes that are newer than this class.
3918                                    // So if we have a process around that we can ask about this object, do so.
3919                                    child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
3920                                    Process *process = NULL;
3921                                    if (exe_ctx)
3922                                        process = exe_ctx->GetProcessPtr();
3923                                    if (process)
3924                                    {
3925                                        ObjCLanguageRuntime *objc_runtime = process->GetObjCLanguageRuntime();
3926                                        if (objc_runtime != NULL)
3927                                        {
3928                                            ClangASTType parent_ast_type (ast, parent_qual_type.getAsOpaquePtr());
3929                                            child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
3930                                        }
3931                                    }
3932
3933                                    // Setting this to UINT32_MAX to make sure we don't compute it twice...
3934                                    bit_offset = UINT32_MAX;
3935
3936                                    if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET)
3937                                    {
3938                                        bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3939                                        child_byte_offset = bit_offset / 8;
3940                                    }
3941
3942                                    // Note, the ObjC Ivar Byte offset is just that, it doesn't account for the bit offset
3943                                    // of a bitfield within its containing object.  So regardless of where we get the byte
3944                                    // offset from, we still need to get the bit offset for bitfields from the layout.
3945
3946                                    if (ClangASTContext::FieldIsBitfield (ast, ivar_decl, child_bitfield_bit_size))
3947                                    {
3948                                        if (bit_offset == UINT32_MAX)
3949                                            bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
3950
3951                                        child_bitfield_bit_offset = bit_offset % 8;
3952                                    }
3953                                    return ivar_qual_type.getAsOpaquePtr();
3954                                }
3955                                ++child_idx;
3956                            }
3957                        }
3958                    }
3959                }
3960            }
3961            break;
3962
3963        case clang::Type::ObjCObjectPointer:
3964            {
3965                const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
3966                QualType pointee_type = pointer_type->getPointeeType();
3967
3968                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3969                {
3970                    child_is_deref_of_parent = false;
3971                    bool tmp_child_is_deref_of_parent = false;
3972                    return GetChildClangTypeAtIndex (exe_ctx,
3973                                                     ast,
3974                                                     parent_name,
3975                                                     pointer_type->getPointeeType().getAsOpaquePtr(),
3976                                                     idx,
3977                                                     transparent_pointers,
3978                                                     omit_empty_base_classes,
3979                                                     ignore_array_bounds,
3980                                                     child_name,
3981                                                     child_byte_size,
3982                                                     child_byte_offset,
3983                                                     child_bitfield_bit_size,
3984                                                     child_bitfield_bit_offset,
3985                                                     child_is_base_class,
3986                                                     tmp_child_is_deref_of_parent);
3987                }
3988                else
3989                {
3990                    child_is_deref_of_parent = true;
3991                    if (parent_name)
3992                    {
3993                        child_name.assign(1, '*');
3994                        child_name += parent_name;
3995                    }
3996
3997                    // We have a pointer to an simple type
3998                    if (idx == 0 && GetCompleteQualType(ast, pointee_type))
3999                    {
4000                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4001                        assert(clang_type_info.first % 8 == 0);
4002                        child_byte_size = clang_type_info.first / 8;
4003                        child_byte_offset = 0;
4004                        return pointee_type.getAsOpaquePtr();
4005                    }
4006                }
4007            }
4008            break;
4009
4010        case clang::Type::ConstantArray:
4011            {
4012                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
4013                const uint64_t element_count = array->getSize().getLimitedValue();
4014
4015                if (ignore_array_bounds || idx < element_count)
4016                {
4017                    if (GetCompleteQualType (ast, array->getElementType()))
4018                    {
4019                        std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
4020
4021                        char element_name[64];
4022                        ::snprintf (element_name, sizeof (element_name), "[%u]", idx);
4023
4024                        child_name.assign(element_name);
4025                        assert(field_type_info.first % 8 == 0);
4026                        child_byte_size = field_type_info.first / 8;
4027                        child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
4028                        return array->getElementType().getAsOpaquePtr();
4029                    }
4030                }
4031            }
4032            break;
4033
4034        case clang::Type::Pointer:
4035            {
4036                const PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
4037                QualType pointee_type = pointer_type->getPointeeType();
4038
4039                // Don't dereference "void *" pointers
4040                if (pointee_type->isVoidType())
4041                    return NULL;
4042
4043                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4044                {
4045                    child_is_deref_of_parent = false;
4046                    bool tmp_child_is_deref_of_parent = false;
4047                    return GetChildClangTypeAtIndex (exe_ctx,
4048                                                     ast,
4049                                                     parent_name,
4050                                                     pointer_type->getPointeeType().getAsOpaquePtr(),
4051                                                     idx,
4052                                                     transparent_pointers,
4053                                                     omit_empty_base_classes,
4054                                                     ignore_array_bounds,
4055                                                     child_name,
4056                                                     child_byte_size,
4057                                                     child_byte_offset,
4058                                                     child_bitfield_bit_size,
4059                                                     child_bitfield_bit_offset,
4060                                                     child_is_base_class,
4061                                                     tmp_child_is_deref_of_parent);
4062                }
4063                else
4064                {
4065                    child_is_deref_of_parent = true;
4066
4067                    if (parent_name)
4068                    {
4069                        child_name.assign(1, '*');
4070                        child_name += parent_name;
4071                    }
4072
4073                    // We have a pointer to an simple type
4074                    if (idx == 0)
4075                    {
4076                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4077                        assert(clang_type_info.first % 8 == 0);
4078                        child_byte_size = clang_type_info.first / 8;
4079                        child_byte_offset = 0;
4080                        return pointee_type.getAsOpaquePtr();
4081                    }
4082                }
4083            }
4084            break;
4085
4086        case clang::Type::LValueReference:
4087        case clang::Type::RValueReference:
4088            {
4089                const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
4090                QualType pointee_type(reference_type->getPointeeType());
4091                clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr();
4092                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type))
4093                {
4094                    child_is_deref_of_parent = false;
4095                    bool tmp_child_is_deref_of_parent = false;
4096                    return GetChildClangTypeAtIndex (exe_ctx,
4097                                                     ast,
4098                                                     parent_name,
4099                                                     pointee_clang_type,
4100                                                     idx,
4101                                                     transparent_pointers,
4102                                                     omit_empty_base_classes,
4103                                                     ignore_array_bounds,
4104                                                     child_name,
4105                                                     child_byte_size,
4106                                                     child_byte_offset,
4107                                                     child_bitfield_bit_size,
4108                                                     child_bitfield_bit_offset,
4109                                                     child_is_base_class,
4110                                                     tmp_child_is_deref_of_parent);
4111                }
4112                else
4113                {
4114                    if (parent_name)
4115                    {
4116                        child_name.assign(1, '&');
4117                        child_name += parent_name;
4118                    }
4119
4120                    // We have a pointer to an simple type
4121                    if (idx == 0)
4122                    {
4123                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4124                        assert(clang_type_info.first % 8 == 0);
4125                        child_byte_size = clang_type_info.first / 8;
4126                        child_byte_offset = 0;
4127                        return pointee_type.getAsOpaquePtr();
4128                    }
4129                }
4130            }
4131            break;
4132
4133        case clang::Type::Typedef:
4134            return GetChildClangTypeAtIndex (exe_ctx,
4135                                             ast,
4136                                             parent_name,
4137                                             cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
4138                                             idx,
4139                                             transparent_pointers,
4140                                             omit_empty_base_classes,
4141                                             ignore_array_bounds,
4142                                             child_name,
4143                                             child_byte_size,
4144                                             child_byte_offset,
4145                                             child_bitfield_bit_size,
4146                                             child_bitfield_bit_offset,
4147                                             child_is_base_class,
4148                                             child_is_deref_of_parent);
4149            break;
4150
4151        case clang::Type::Elaborated:
4152            return GetChildClangTypeAtIndex (exe_ctx,
4153                                             ast,
4154                                             parent_name,
4155                                             cast<ElaboratedType>(parent_qual_type)->getNamedType().getAsOpaquePtr(),
4156                                             idx,
4157                                             transparent_pointers,
4158                                             omit_empty_base_classes,
4159                                             ignore_array_bounds,
4160                                             child_name,
4161                                             child_byte_size,
4162                                             child_byte_offset,
4163                                             child_bitfield_bit_size,
4164                                             child_bitfield_bit_offset,
4165                                             child_is_base_class,
4166                                             child_is_deref_of_parent);
4167
4168        default:
4169            break;
4170        }
4171    }
4172    return NULL;
4173}
4174
4175static inline bool
4176BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
4177{
4178    return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
4179}
4180
4181static uint32_t
4182GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
4183{
4184    uint32_t num_bases = 0;
4185    if (cxx_record_decl)
4186    {
4187        if (omit_empty_base_classes)
4188        {
4189            CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
4190            for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
4191                 base_class != base_class_end;
4192                 ++base_class)
4193            {
4194                // Skip empty base classes
4195                if (omit_empty_base_classes)
4196                {
4197                    if (BaseSpecifierIsEmpty (base_class))
4198                        continue;
4199                }
4200                ++num_bases;
4201            }
4202        }
4203        else
4204            num_bases = cxx_record_decl->getNumBases();
4205    }
4206    return num_bases;
4207}
4208
4209
4210static uint32_t
4211GetIndexForRecordBase
4212(
4213    const RecordDecl *record_decl,
4214    const CXXBaseSpecifier *base_spec,
4215    bool omit_empty_base_classes
4216)
4217{
4218    uint32_t child_idx = 0;
4219
4220    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
4221
4222//    const char *super_name = record_decl->getNameAsCString();
4223//    const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
4224//    printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
4225//
4226    if (cxx_record_decl)
4227    {
4228        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
4229        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
4230             base_class != base_class_end;
4231             ++base_class)
4232        {
4233            if (omit_empty_base_classes)
4234            {
4235                if (BaseSpecifierIsEmpty (base_class))
4236                    continue;
4237            }
4238
4239//            printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
4240//                    child_idx,
4241//                    base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
4242//
4243//
4244            if (base_class == base_spec)
4245                return child_idx;
4246            ++child_idx;
4247        }
4248    }
4249
4250    return UINT32_MAX;
4251}
4252
4253
4254static uint32_t
4255GetIndexForRecordChild
4256(
4257    const RecordDecl *record_decl,
4258    NamedDecl *canonical_decl,
4259    bool omit_empty_base_classes
4260)
4261{
4262    uint32_t child_idx = GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), omit_empty_base_classes);
4263
4264//    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
4265//
4266////    printf ("GetIndexForRecordChild (%s, %s)\n", record_decl->getNameAsCString(), canonical_decl->getNameAsCString());
4267//    if (cxx_record_decl)
4268//    {
4269//        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
4270//        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
4271//             base_class != base_class_end;
4272//             ++base_class)
4273//        {
4274//            if (omit_empty_base_classes)
4275//            {
4276//                if (BaseSpecifierIsEmpty (base_class))
4277//                    continue;
4278//            }
4279//
4280////            printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n",
4281////                    record_decl->getNameAsCString(),
4282////                    canonical_decl->getNameAsCString(),
4283////                    child_idx,
4284////                    base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
4285//
4286//
4287//            CXXRecordDecl *curr_base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
4288//            if (curr_base_class_decl == canonical_decl)
4289//            {
4290//                return child_idx;
4291//            }
4292//            ++child_idx;
4293//        }
4294//    }
4295//
4296//    const uint32_t num_bases = child_idx;
4297    RecordDecl::field_iterator field, field_end;
4298    for (field = record_decl->field_begin(), field_end = record_decl->field_end();
4299         field != field_end;
4300         ++field, ++child_idx)
4301    {
4302//            printf ("GetIndexForRecordChild (%s, %s) field[%u] = %s\n",
4303//                    record_decl->getNameAsCString(),
4304//                    canonical_decl->getNameAsCString(),
4305//                    child_idx - num_bases,
4306//                    field->getNameAsCString());
4307
4308        if (field->getCanonicalDecl() == canonical_decl)
4309            return child_idx;
4310    }
4311
4312    return UINT32_MAX;
4313}
4314
4315// Look for a child member (doesn't include base classes, but it does include
4316// their members) in the type hierarchy. Returns an index path into "clang_type"
4317// on how to reach the appropriate member.
4318//
4319//    class A
4320//    {
4321//    public:
4322//        int m_a;
4323//        int m_b;
4324//    };
4325//
4326//    class B
4327//    {
4328//    };
4329//
4330//    class C :
4331//        public B,
4332//        public A
4333//    {
4334//    };
4335//
4336// If we have a clang type that describes "class C", and we wanted to looked
4337// "m_b" in it:
4338//
4339// With omit_empty_base_classes == false we would get an integer array back with:
4340// { 1,  1 }
4341// The first index 1 is the child index for "class A" within class C
4342// The second index 1 is the child index for "m_b" within class A
4343//
4344// With omit_empty_base_classes == true we would get an integer array back with:
4345// { 0,  1 }
4346// The first index 0 is the child index for "class A" within class C (since class B doesn't have any members it doesn't count)
4347// The second index 1 is the child index for "m_b" within class A
4348
4349size_t
4350ClangASTContext::GetIndexOfChildMemberWithName
4351(
4352    ASTContext *ast,
4353    clang_type_t clang_type,
4354    const char *name,
4355    bool omit_empty_base_classes,
4356    std::vector<uint32_t>& child_indexes
4357)
4358{
4359    if (clang_type && name && name[0])
4360    {
4361        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
4362        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4363        switch (type_class)
4364        {
4365        case clang::Type::Record:
4366            if (GetCompleteQualType (ast, qual_type))
4367            {
4368                const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
4369                const RecordDecl *record_decl = record_type->getDecl();
4370
4371                assert(record_decl);
4372                uint32_t child_idx = 0;
4373
4374                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
4375
4376                // Try and find a field that matches NAME
4377                RecordDecl::field_iterator field, field_end;
4378                StringRef name_sref(name);
4379                for (field = record_decl->field_begin(), field_end = record_decl->field_end();
4380                     field != field_end;
4381                     ++field, ++child_idx)
4382                {
4383                    if (field->getName().equals (name_sref))
4384                    {
4385                        // We have to add on the number of base classes to this index!
4386                        child_indexes.push_back (child_idx + GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
4387                        return child_indexes.size();
4388                    }
4389                }
4390
4391                if (cxx_record_decl)
4392                {
4393                    const RecordDecl *parent_record_decl = cxx_record_decl;
4394
4395                    //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
4396
4397                    //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
4398                    // Didn't find things easily, lets let clang do its thang...
4399                    IdentifierInfo & ident_ref = ast->Idents.get(name_sref);
4400                    DeclarationName decl_name(&ident_ref);
4401
4402                    CXXBasePaths paths;
4403                    if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
4404                                                       decl_name.getAsOpaquePtr(),
4405                                                       paths))
4406                    {
4407                        CXXBasePaths::const_paths_iterator path, path_end = paths.end();
4408                        for (path = paths.begin(); path != path_end; ++path)
4409                        {
4410                            const size_t num_path_elements = path->size();
4411                            for (size_t e=0; e<num_path_elements; ++e)
4412                            {
4413                                CXXBasePathElement elem = (*path)[e];
4414
4415                                child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
4416                                if (child_idx == UINT32_MAX)
4417                                {
4418                                    child_indexes.clear();
4419                                    return 0;
4420                                }
4421                                else
4422                                {
4423                                    child_indexes.push_back (child_idx);
4424                                    parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
4425                                }
4426                            }
4427                            DeclContext::lookup_iterator named_decl_pos;
4428                            for (named_decl_pos = path->Decls.first;
4429                                 named_decl_pos != path->Decls.second && parent_record_decl;
4430                                 ++named_decl_pos)
4431                            {
4432                                //printf ("path[%zu] = %s\n", child_indexes.size(), (*named_decl_pos)->getNameAsCString());
4433
4434                                child_idx = GetIndexForRecordChild (parent_record_decl, *named_decl_pos, omit_empty_base_classes);
4435                                if (child_idx == UINT32_MAX)
4436                                {
4437                                    child_indexes.clear();
4438                                    return 0;
4439                                }
4440                                else
4441                                {
4442                                    child_indexes.push_back (child_idx);
4443                                }
4444                            }
4445                        }
4446                        return child_indexes.size();
4447                    }
4448                }
4449
4450            }
4451            break;
4452
4453        case clang::Type::ObjCObject:
4454        case clang::Type::ObjCInterface:
4455            if (GetCompleteQualType (ast, qual_type))
4456            {
4457                StringRef name_sref(name);
4458                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
4459                assert (objc_class_type);
4460                if (objc_class_type)
4461                {
4462                    uint32_t child_idx = 0;
4463                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4464
4465                    if (class_interface_decl)
4466                    {
4467                        ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
4468                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
4469
4470                        for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
4471                        {
4472                            const ObjCIvarDecl* ivar_decl = *ivar_pos;
4473
4474                            if (ivar_decl->getName().equals (name_sref))
4475                            {
4476                                if ((!omit_empty_base_classes && superclass_interface_decl) ||
4477                                    ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
4478                                    ++child_idx;
4479
4480                                child_indexes.push_back (child_idx);
4481                                return child_indexes.size();
4482                            }
4483                        }
4484
4485                        if (superclass_interface_decl)
4486                        {
4487                            // The super class index is always zero for ObjC classes,
4488                            // so we push it onto the child indexes in case we find
4489                            // an ivar in our superclass...
4490                            child_indexes.push_back (0);
4491
4492                            if (GetIndexOfChildMemberWithName (ast,
4493                                                               ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(),
4494                                                               name,
4495                                                               omit_empty_base_classes,
4496                                                               child_indexes))
4497                            {
4498                                // We did find an ivar in a superclass so just
4499                                // return the results!
4500                                return child_indexes.size();
4501                            }
4502
4503                            // We didn't find an ivar matching "name" in our
4504                            // superclass, pop the superclass zero index that
4505                            // we pushed on above.
4506                            child_indexes.pop_back();
4507                        }
4508                    }
4509                }
4510            }
4511            break;
4512
4513        case clang::Type::ObjCObjectPointer:
4514            {
4515                return GetIndexOfChildMemberWithName (ast,
4516                                                      cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
4517                                                      name,
4518                                                      omit_empty_base_classes,
4519                                                      child_indexes);
4520            }
4521            break;
4522
4523
4524        case clang::Type::ConstantArray:
4525            {
4526//                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
4527//                const uint64_t element_count = array->getSize().getLimitedValue();
4528//
4529//                if (idx < element_count)
4530//                {
4531//                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
4532//
4533//                    char element_name[32];
4534//                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
4535//
4536//                    child_name.assign(element_name);
4537//                    assert(field_type_info.first % 8 == 0);
4538//                    child_byte_size = field_type_info.first / 8;
4539//                    child_byte_offset = idx * child_byte_size;
4540//                    return array->getElementType().getAsOpaquePtr();
4541//                }
4542            }
4543            break;
4544
4545//        case clang::Type::MemberPointerType:
4546//            {
4547//                MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
4548//                QualType pointee_type = mem_ptr_type->getPointeeType();
4549//
4550//                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4551//                {
4552//                    return GetIndexOfChildWithName (ast,
4553//                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
4554//                                                    name);
4555//                }
4556//            }
4557//            break;
4558//
4559        case clang::Type::LValueReference:
4560        case clang::Type::RValueReference:
4561            {
4562                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
4563                QualType pointee_type = reference_type->getPointeeType();
4564
4565                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4566                {
4567                    return GetIndexOfChildMemberWithName (ast,
4568                                                          reference_type->getPointeeType().getAsOpaquePtr(),
4569                                                          name,
4570                                                          omit_empty_base_classes,
4571                                                          child_indexes);
4572                }
4573            }
4574            break;
4575
4576        case clang::Type::Pointer:
4577            {
4578                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
4579                QualType pointee_type = pointer_type->getPointeeType();
4580
4581                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4582                {
4583                    return GetIndexOfChildMemberWithName (ast,
4584                                                          pointer_type->getPointeeType().getAsOpaquePtr(),
4585                                                          name,
4586                                                          omit_empty_base_classes,
4587                                                          child_indexes);
4588                }
4589                else
4590                {
4591//                    if (parent_name)
4592//                    {
4593//                        child_name.assign(1, '*');
4594//                        child_name += parent_name;
4595//                    }
4596//
4597//                    // We have a pointer to an simple type
4598//                    if (idx == 0)
4599//                    {
4600//                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4601//                        assert(clang_type_info.first % 8 == 0);
4602//                        child_byte_size = clang_type_info.first / 8;
4603//                        child_byte_offset = 0;
4604//                        return pointee_type.getAsOpaquePtr();
4605//                    }
4606                }
4607            }
4608            break;
4609
4610        case clang::Type::Typedef:
4611            return GetIndexOfChildMemberWithName (ast,
4612                                                  cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
4613                                                  name,
4614                                                  omit_empty_base_classes,
4615                                                  child_indexes);
4616
4617        default:
4618            break;
4619        }
4620    }
4621    return 0;
4622}
4623
4624
4625// Get the index of the child of "clang_type" whose name matches. This function
4626// doesn't descend into the children, but only looks one level deep and name
4627// matches can include base class names.
4628
4629uint32_t
4630ClangASTContext::GetIndexOfChildWithName
4631(
4632    ASTContext *ast,
4633    clang_type_t clang_type,
4634    const char *name,
4635    bool omit_empty_base_classes
4636)
4637{
4638    if (clang_type && name && name[0])
4639    {
4640        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
4641
4642        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4643
4644        switch (type_class)
4645        {
4646        case clang::Type::Record:
4647            if (GetCompleteQualType (ast, qual_type))
4648            {
4649                const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
4650                const RecordDecl *record_decl = record_type->getDecl();
4651
4652                assert(record_decl);
4653                uint32_t child_idx = 0;
4654
4655                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
4656
4657                if (cxx_record_decl)
4658                {
4659                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
4660                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
4661                         base_class != base_class_end;
4662                         ++base_class)
4663                    {
4664                        // Skip empty base classes
4665                        CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
4666                        if (omit_empty_base_classes && RecordHasFields(base_class_decl) == false)
4667                            continue;
4668
4669                        std::string base_class_type_name (ClangASTType::GetTypeNameForQualType(ast, base_class->getType()));
4670                        if (base_class_type_name.compare (name) == 0)
4671                            return child_idx;
4672                        ++child_idx;
4673                    }
4674                }
4675
4676                // Try and find a field that matches NAME
4677                RecordDecl::field_iterator field, field_end;
4678                StringRef name_sref(name);
4679                for (field = record_decl->field_begin(), field_end = record_decl->field_end();
4680                     field != field_end;
4681                     ++field, ++child_idx)
4682                {
4683                    if (field->getName().equals (name_sref))
4684                        return child_idx;
4685                }
4686
4687            }
4688            break;
4689
4690        case clang::Type::ObjCObject:
4691        case clang::Type::ObjCInterface:
4692            if (GetCompleteQualType (ast, qual_type))
4693            {
4694                StringRef name_sref(name);
4695                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
4696                assert (objc_class_type);
4697                if (objc_class_type)
4698                {
4699                    uint32_t child_idx = 0;
4700                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
4701
4702                    if (class_interface_decl)
4703                    {
4704                        ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
4705                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
4706
4707                        for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
4708                        {
4709                            const ObjCIvarDecl* ivar_decl = *ivar_pos;
4710
4711                            if (ivar_decl->getName().equals (name_sref))
4712                            {
4713                                if ((!omit_empty_base_classes && superclass_interface_decl) ||
4714                                    ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
4715                                    ++child_idx;
4716
4717                                return child_idx;
4718                            }
4719                        }
4720
4721                        if (superclass_interface_decl)
4722                        {
4723                            if (superclass_interface_decl->getName().equals (name_sref))
4724                                return 0;
4725                        }
4726                    }
4727                }
4728            }
4729            break;
4730
4731        case clang::Type::ObjCObjectPointer:
4732            {
4733                return GetIndexOfChildWithName (ast,
4734                                                cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
4735                                                name,
4736                                                omit_empty_base_classes);
4737            }
4738            break;
4739
4740        case clang::Type::ConstantArray:
4741            {
4742//                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
4743//                const uint64_t element_count = array->getSize().getLimitedValue();
4744//
4745//                if (idx < element_count)
4746//                {
4747//                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
4748//
4749//                    char element_name[32];
4750//                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
4751//
4752//                    child_name.assign(element_name);
4753//                    assert(field_type_info.first % 8 == 0);
4754//                    child_byte_size = field_type_info.first / 8;
4755//                    child_byte_offset = idx * child_byte_size;
4756//                    return array->getElementType().getAsOpaquePtr();
4757//                }
4758            }
4759            break;
4760
4761//        case clang::Type::MemberPointerType:
4762//            {
4763//                MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
4764//                QualType pointee_type = mem_ptr_type->getPointeeType();
4765//
4766//                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4767//                {
4768//                    return GetIndexOfChildWithName (ast,
4769//                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
4770//                                                    name);
4771//                }
4772//            }
4773//            break;
4774//
4775        case clang::Type::LValueReference:
4776        case clang::Type::RValueReference:
4777            {
4778                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
4779                QualType pointee_type = reference_type->getPointeeType();
4780
4781                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4782                {
4783                    return GetIndexOfChildWithName (ast,
4784                                                    reference_type->getPointeeType().getAsOpaquePtr(),
4785                                                    name,
4786                                                    omit_empty_base_classes);
4787                }
4788            }
4789            break;
4790
4791        case clang::Type::Pointer:
4792            {
4793                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
4794                QualType pointee_type = pointer_type->getPointeeType();
4795
4796                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
4797                {
4798                    return GetIndexOfChildWithName (ast,
4799                                                    pointer_type->getPointeeType().getAsOpaquePtr(),
4800                                                    name,
4801                                                    omit_empty_base_classes);
4802                }
4803                else
4804                {
4805//                    if (parent_name)
4806//                    {
4807//                        child_name.assign(1, '*');
4808//                        child_name += parent_name;
4809//                    }
4810//
4811//                    // We have a pointer to an simple type
4812//                    if (idx == 0)
4813//                    {
4814//                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
4815//                        assert(clang_type_info.first % 8 == 0);
4816//                        child_byte_size = clang_type_info.first / 8;
4817//                        child_byte_offset = 0;
4818//                        return pointee_type.getAsOpaquePtr();
4819//                    }
4820                }
4821            }
4822            break;
4823
4824        case clang::Type::Typedef:
4825            return GetIndexOfChildWithName (ast,
4826                                            cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
4827                                            name,
4828                                            omit_empty_base_classes);
4829
4830        default:
4831            break;
4832        }
4833    }
4834    return UINT32_MAX;
4835}
4836
4837#pragma mark TagType
4838
4839bool
4840ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind)
4841{
4842    if (tag_clang_type)
4843    {
4844        QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type));
4845        const clang::Type *clang_type = tag_qual_type.getTypePtr();
4846        if (clang_type)
4847        {
4848            const TagType *tag_type = dyn_cast<TagType>(clang_type);
4849            if (tag_type)
4850            {
4851                TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
4852                if (tag_decl)
4853                {
4854                    tag_decl->setTagKind ((TagDecl::TagKind)kind);
4855                    return true;
4856                }
4857            }
4858        }
4859    }
4860    return false;
4861}
4862
4863
4864#pragma mark DeclContext Functions
4865
4866DeclContext *
4867ClangASTContext::GetDeclContextForType (clang_type_t clang_type)
4868{
4869    if (clang_type == NULL)
4870        return NULL;
4871
4872    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
4873    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4874    switch (type_class)
4875    {
4876    case clang::Type::UnaryTransform:           break;
4877    case clang::Type::FunctionNoProto:          break;
4878    case clang::Type::FunctionProto:            break;
4879    case clang::Type::IncompleteArray:          break;
4880    case clang::Type::VariableArray:            break;
4881    case clang::Type::ConstantArray:            break;
4882    case clang::Type::DependentSizedArray:      break;
4883    case clang::Type::ExtVector:                break;
4884    case clang::Type::DependentSizedExtVector:  break;
4885    case clang::Type::Vector:                   break;
4886    case clang::Type::Builtin:                  break;
4887    case clang::Type::BlockPointer:             break;
4888    case clang::Type::Pointer:                  break;
4889    case clang::Type::LValueReference:          break;
4890    case clang::Type::RValueReference:          break;
4891    case clang::Type::MemberPointer:            break;
4892    case clang::Type::Complex:                  break;
4893    case clang::Type::ObjCObject:               break;
4894    case clang::Type::ObjCInterface:            return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
4895    case clang::Type::ObjCObjectPointer:        return ClangASTContext::GetDeclContextForType (cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr());
4896    case clang::Type::Record:                   return cast<RecordType>(qual_type)->getDecl();
4897    case clang::Type::Enum:                     return cast<EnumType>(qual_type)->getDecl();
4898    case clang::Type::Typedef:                  return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
4899    case clang::Type::Elaborated:               return ClangASTContext::GetDeclContextForType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
4900    case clang::Type::TypeOfExpr:               break;
4901    case clang::Type::TypeOf:                   break;
4902    case clang::Type::Decltype:                 break;
4903    //case clang::Type::QualifiedName:          break;
4904    case clang::Type::TemplateSpecialization:   break;
4905    case clang::Type::DependentTemplateSpecialization:  break;
4906    case clang::Type::TemplateTypeParm:         break;
4907    case clang::Type::SubstTemplateTypeParm:    break;
4908    case clang::Type::SubstTemplateTypeParmPack:break;
4909    case clang::Type::PackExpansion:            break;
4910    case clang::Type::UnresolvedUsing:          break;
4911    case clang::Type::Paren:                    break;
4912    case clang::Type::Attributed:               break;
4913    case clang::Type::Auto:                     break;
4914    case clang::Type::InjectedClassName:        break;
4915    case clang::Type::DependentName:            break;
4916    case clang::Type::Atomic:                   break;
4917    }
4918    // No DeclContext in this type...
4919    return NULL;
4920}
4921
4922#pragma mark Namespace Declarations
4923
4924NamespaceDecl *
4925ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx)
4926{
4927    NamespaceDecl *namespace_decl = NULL;
4928    ASTContext *ast = getASTContext();
4929    TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl ();
4930    if (decl_ctx == NULL)
4931        decl_ctx = translation_unit_decl;
4932
4933    if (name)
4934    {
4935        IdentifierInfo &identifier_info = ast->Idents.get(name);
4936        DeclarationName decl_name (&identifier_info);
4937        clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
4938        for (clang::DeclContext::lookup_iterator pos = result.first, end = result.second; pos != end; ++pos)
4939        {
4940            namespace_decl = dyn_cast<clang::NamespaceDecl>(*pos);
4941            if (namespace_decl)
4942                return namespace_decl;
4943        }
4944
4945        namespace_decl = NamespaceDecl::Create(*ast,
4946                                               decl_ctx,
4947                                               false,
4948                                               SourceLocation(),
4949                                               SourceLocation(),
4950                                               &identifier_info,
4951                                               NULL);
4952
4953        decl_ctx->addDecl (namespace_decl);
4954    }
4955    else
4956    {
4957        if (decl_ctx == translation_unit_decl)
4958        {
4959            namespace_decl = translation_unit_decl->getAnonymousNamespace();
4960            if (namespace_decl)
4961                return namespace_decl;
4962
4963            namespace_decl = NamespaceDecl::Create(*ast,
4964                                                   decl_ctx,
4965                                                   false,
4966                                                   SourceLocation(),
4967                                                   SourceLocation(),
4968                                                   NULL,
4969                                                   NULL);
4970            translation_unit_decl->setAnonymousNamespace (namespace_decl);
4971            translation_unit_decl->addDecl (namespace_decl);
4972            assert (namespace_decl == translation_unit_decl->getAnonymousNamespace());
4973        }
4974        else
4975        {
4976            NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
4977            if (parent_namespace_decl)
4978            {
4979                namespace_decl = parent_namespace_decl->getAnonymousNamespace();
4980                if (namespace_decl)
4981                    return namespace_decl;
4982                namespace_decl = NamespaceDecl::Create(*ast,
4983                                                       decl_ctx,
4984                                                       false,
4985                                                       SourceLocation(),
4986                                                       SourceLocation(),
4987                                                       NULL,
4988                                                       NULL);
4989                parent_namespace_decl->setAnonymousNamespace (namespace_decl);
4990                parent_namespace_decl->addDecl (namespace_decl);
4991                assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace());
4992            }
4993            else
4994            {
4995                // BAD!!!
4996            }
4997        }
4998
4999
5000        if (namespace_decl)
5001        {
5002            // If we make it here, we are creating the anonymous namespace decl
5003            // for the first time, so we need to do the using directive magic
5004            // like SEMA does
5005            UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast,
5006                                                                                   decl_ctx,
5007                                                                                   SourceLocation(),
5008                                                                                   SourceLocation(),
5009                                                                                   NestedNameSpecifierLoc(),
5010                                                                                   SourceLocation(),
5011                                                                                   namespace_decl,
5012                                                                                   decl_ctx);
5013            using_directive_decl->setImplicit();
5014            decl_ctx->addDecl(using_directive_decl);
5015        }
5016    }
5017#ifdef LLDB_CONFIGURATION_DEBUG
5018    VerifyDecl(namespace_decl);
5019#endif
5020    return namespace_decl;
5021}
5022
5023
5024#pragma mark Function Types
5025
5026FunctionDecl *
5027ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx, const char *name, clang_type_t function_clang_type, int storage, bool is_inline)
5028{
5029    FunctionDecl *func_decl = NULL;
5030    ASTContext *ast = getASTContext();
5031    if (decl_ctx == NULL)
5032        decl_ctx = ast->getTranslationUnitDecl();
5033
5034    if (name && name[0])
5035    {
5036        func_decl = FunctionDecl::Create (*ast,
5037                                          decl_ctx,
5038                                          SourceLocation(),
5039                                          SourceLocation(),
5040                                          DeclarationName (&ast->Idents.get(name)),
5041                                          QualType::getFromOpaquePtr(function_clang_type),
5042                                          NULL,
5043                                          (FunctionDecl::StorageClass)storage,
5044                                          (FunctionDecl::StorageClass)storage,
5045                                          is_inline);
5046    }
5047    else
5048    {
5049        func_decl = FunctionDecl::Create (*ast,
5050                                          decl_ctx,
5051                                          SourceLocation(),
5052                                          SourceLocation(),
5053                                          DeclarationName (),
5054                                          QualType::getFromOpaquePtr(function_clang_type),
5055                                          NULL,
5056                                          (FunctionDecl::StorageClass)storage,
5057                                          (FunctionDecl::StorageClass)storage,
5058                                          is_inline);
5059    }
5060    if (func_decl)
5061        decl_ctx->addDecl (func_decl);
5062
5063#ifdef LLDB_CONFIGURATION_DEBUG
5064    VerifyDecl(func_decl);
5065#endif
5066
5067    return func_decl;
5068}
5069
5070clang_type_t
5071ClangASTContext::CreateFunctionType (ASTContext *ast,
5072                                     clang_type_t result_type,
5073                                     clang_type_t *args,
5074                                     unsigned num_args,
5075                                     bool is_variadic,
5076                                     unsigned type_quals)
5077{
5078    assert (ast != NULL);
5079    std::vector<QualType> qual_type_args;
5080    for (unsigned i=0; i<num_args; ++i)
5081        qual_type_args.push_back (QualType::getFromOpaquePtr(args[i]));
5082
5083    // TODO: Detect calling convention in DWARF?
5084    FunctionProtoType::ExtProtoInfo proto_info;
5085    proto_info.Variadic = is_variadic;
5086    proto_info.ExceptionSpecType = EST_None;
5087    proto_info.TypeQuals = type_quals;
5088    proto_info.RefQualifier = RQ_None;
5089    proto_info.NumExceptions = 0;
5090    proto_info.Exceptions = NULL;
5091
5092    return ast->getFunctionType (QualType::getFromOpaquePtr(result_type),
5093                                 qual_type_args.empty() ? NULL : &qual_type_args.front(),
5094                                 qual_type_args.size(),
5095                                 proto_info).getAsOpaquePtr();    // NoReturn);
5096}
5097
5098ParmVarDecl *
5099ClangASTContext::CreateParameterDeclaration (const char *name, clang_type_t param_type, int storage)
5100{
5101    ASTContext *ast = getASTContext();
5102    assert (ast != NULL);
5103    return ParmVarDecl::Create(*ast,
5104                                ast->getTranslationUnitDecl(),
5105                                SourceLocation(),
5106                                SourceLocation(),
5107                                name && name[0] ? &ast->Idents.get(name) : NULL,
5108                                QualType::getFromOpaquePtr(param_type),
5109                                NULL,
5110                                (VarDecl::StorageClass)storage,
5111                                (VarDecl::StorageClass)storage,
5112                                0);
5113}
5114
5115void
5116ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
5117{
5118    if (function_decl)
5119        function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params));
5120}
5121
5122
5123#pragma mark Array Types
5124
5125clang_type_t
5126ClangASTContext::CreateArrayType (clang_type_t element_type, size_t element_count, uint32_t bit_stride)
5127{
5128    if (element_type)
5129    {
5130        ASTContext *ast = getASTContext();
5131        assert (ast != NULL);
5132        llvm::APInt ap_element_count (64, element_count);
5133        return ast->getConstantArrayType(QualType::getFromOpaquePtr(element_type),
5134                                                 ap_element_count,
5135                                                 ArrayType::Normal,
5136                                                 0).getAsOpaquePtr(); // ElemQuals
5137    }
5138    return NULL;
5139}
5140
5141
5142#pragma mark TagDecl
5143
5144bool
5145ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type)
5146{
5147    if (clang_type)
5148    {
5149        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5150        const clang::Type *t = qual_type.getTypePtr();
5151        if (t)
5152        {
5153            const TagType *tag_type = dyn_cast<TagType>(t);
5154            if (tag_type)
5155            {
5156                TagDecl *tag_decl = tag_type->getDecl();
5157                if (tag_decl)
5158                {
5159                    tag_decl->startDefinition();
5160                    return true;
5161                }
5162            }
5163
5164            const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(t);
5165            if (object_type)
5166            {
5167                ObjCInterfaceDecl *interface_decl = object_type->getInterface();
5168                if (interface_decl)
5169                {
5170                    interface_decl->startDefinition();
5171                    return true;
5172                }
5173            }
5174        }
5175    }
5176    return false;
5177}
5178
5179bool
5180ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type)
5181{
5182    if (clang_type)
5183    {
5184        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5185
5186        CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5187
5188        if (cxx_record_decl)
5189        {
5190            cxx_record_decl->completeDefinition();
5191
5192            return true;
5193        }
5194
5195        const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
5196
5197        if (enum_type)
5198        {
5199            EnumDecl *enum_decl = enum_type->getDecl();
5200
5201            if (enum_decl)
5202            {
5203                /// TODO This really needs to be fixed.
5204
5205                unsigned NumPositiveBits = 1;
5206                unsigned NumNegativeBits = 0;
5207
5208                ASTContext *ast = getASTContext();
5209
5210                QualType promotion_qual_type;
5211                // If the enum integer type is less than an integer in bit width,
5212                // then we must promote it to an integer size.
5213                if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy))
5214                {
5215                    if (enum_decl->getIntegerType()->isSignedIntegerType())
5216                        promotion_qual_type = ast->IntTy;
5217                    else
5218                        promotion_qual_type = ast->UnsignedIntTy;
5219                }
5220                else
5221                    promotion_qual_type = enum_decl->getIntegerType();
5222
5223                enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
5224                return true;
5225            }
5226        }
5227    }
5228    return false;
5229}
5230
5231
5232#pragma mark Enumeration Types
5233
5234clang_type_t
5235ClangASTContext::CreateEnumerationType
5236(
5237    const char *name,
5238    DeclContext *decl_ctx,
5239    const Declaration &decl,
5240    clang_type_t integer_qual_type
5241)
5242{
5243    // TODO: Do something intelligent with the Declaration object passed in
5244    // like maybe filling in the SourceLocation with it...
5245    ASTContext *ast = getASTContext();
5246    assert (ast != NULL);
5247
5248    // TODO: ask about these...
5249//    const bool IsScoped = false;
5250//    const bool IsFixed = false;
5251
5252    EnumDecl *enum_decl = EnumDecl::Create (*ast,
5253                                            decl_ctx,
5254                                            SourceLocation(),
5255                                            SourceLocation(),
5256                                            name && name[0] ? &ast->Idents.get(name) : NULL,
5257                                            NULL,
5258                                            false,  // IsScoped
5259                                            false,  // IsScopedUsingClassTag
5260                                            false); // IsFixed
5261
5262
5263    if (enum_decl)
5264    {
5265        // TODO: check if we should be setting the promotion type too?
5266        enum_decl->setIntegerType(QualType::getFromOpaquePtr (integer_qual_type));
5267
5268        enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
5269
5270        return ast->getTagDeclType(enum_decl).getAsOpaquePtr();
5271    }
5272    return NULL;
5273}
5274
5275clang_type_t
5276ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type)
5277{
5278    QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
5279
5280    const clang::Type *clang_type = enum_qual_type.getTypePtr();
5281    if (clang_type)
5282    {
5283        const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
5284        if (enum_type)
5285        {
5286            EnumDecl *enum_decl = enum_type->getDecl();
5287            if (enum_decl)
5288                return enum_decl->getIntegerType().getAsOpaquePtr();
5289        }
5290    }
5291    return NULL;
5292}
5293bool
5294ClangASTContext::AddEnumerationValueToEnumerationType
5295(
5296    clang_type_t enum_clang_type,
5297    clang_type_t enumerator_clang_type,
5298    const Declaration &decl,
5299    const char *name,
5300    int64_t enum_value,
5301    uint32_t enum_value_bit_size
5302)
5303{
5304    if (enum_clang_type && enumerator_clang_type && name)
5305    {
5306        // TODO: Do something intelligent with the Declaration object passed in
5307        // like maybe filling in the SourceLocation with it...
5308        ASTContext *ast = getASTContext();
5309        IdentifierTable *identifier_table = getIdentifierTable();
5310
5311        assert (ast != NULL);
5312        assert (identifier_table != NULL);
5313        QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
5314
5315        const clang::Type *clang_type = enum_qual_type.getTypePtr();
5316        if (clang_type)
5317        {
5318            const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
5319
5320            if (enum_type)
5321            {
5322                llvm::APSInt enum_llvm_apsint(enum_value_bit_size, false);
5323                enum_llvm_apsint = enum_value;
5324                EnumConstantDecl *enumerator_decl =
5325                    EnumConstantDecl::Create (*ast,
5326                                              enum_type->getDecl(),
5327                                              SourceLocation(),
5328                                              name ? &identifier_table->get(name) : NULL,    // Identifier
5329                                              QualType::getFromOpaquePtr(enumerator_clang_type),
5330                                              NULL,
5331                                              enum_llvm_apsint);
5332
5333                if (enumerator_decl)
5334                {
5335                    enum_type->getDecl()->addDecl(enumerator_decl);
5336
5337#ifdef LLDB_CONFIGURATION_DEBUG
5338                    VerifyDecl(enumerator_decl);
5339#endif
5340
5341                    return true;
5342                }
5343            }
5344        }
5345    }
5346    return false;
5347}
5348
5349#pragma mark Pointers & References
5350
5351clang_type_t
5352ClangASTContext::CreatePointerType (clang_type_t clang_type)
5353{
5354    return CreatePointerType (getASTContext(), clang_type);
5355}
5356
5357clang_type_t
5358ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type)
5359{
5360    if (ast && clang_type)
5361    {
5362        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5363
5364        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5365        switch (type_class)
5366        {
5367        case clang::Type::ObjCObject:
5368        case clang::Type::ObjCInterface:
5369            return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
5370
5371        default:
5372            return ast->getPointerType(qual_type).getAsOpaquePtr();
5373        }
5374    }
5375    return NULL;
5376}
5377
5378clang_type_t
5379ClangASTContext::CreateLValueReferenceType (clang::ASTContext *ast,
5380                                            clang_type_t clang_type)
5381{
5382    if (clang_type)
5383        return ast->getLValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
5384    return NULL;
5385}
5386
5387clang_type_t
5388ClangASTContext::CreateRValueReferenceType (clang::ASTContext *ast,
5389                                            clang_type_t clang_type)
5390{
5391    if (clang_type)
5392        return ast->getRValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
5393    return NULL;
5394}
5395
5396clang_type_t
5397ClangASTContext::CreateMemberPointerType (clang_type_t clang_pointee_type, clang_type_t clang_class_type)
5398{
5399    if (clang_pointee_type && clang_pointee_type)
5400        return getASTContext()->getMemberPointerType(QualType::getFromOpaquePtr(clang_pointee_type),
5401                                                     QualType::getFromOpaquePtr(clang_class_type).getTypePtr()).getAsOpaquePtr();
5402    return NULL;
5403}
5404
5405uint32_t
5406ClangASTContext::GetPointerBitSize ()
5407{
5408    ASTContext *ast = getASTContext();
5409    return ast->getTypeSize(ast->VoidPtrTy);
5410}
5411
5412bool
5413ClangASTContext::IsPossibleDynamicType (clang::ASTContext *ast,
5414                                        clang_type_t clang_type,
5415                                        clang_type_t *dynamic_pointee_type,
5416                                        bool check_cplusplus,
5417                                        bool check_objc)
5418{
5419    QualType pointee_qual_type;
5420    if (clang_type)
5421    {
5422        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5423        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5424        bool success = false;
5425        switch (type_class)
5426        {
5427            case clang::Type::Builtin:
5428                if (check_objc && cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId)
5429                {
5430                    if (dynamic_pointee_type)
5431                        *dynamic_pointee_type = clang_type;
5432                    return true;
5433                }
5434                break;
5435
5436            case clang::Type::ObjCObjectPointer:
5437                if (check_objc)
5438                {
5439                    if (dynamic_pointee_type)
5440                        *dynamic_pointee_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5441                    return true;
5442                }
5443                break;
5444
5445            case clang::Type::Pointer:
5446                pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType();
5447                success = true;
5448                break;
5449
5450            case clang::Type::LValueReference:
5451            case clang::Type::RValueReference:
5452                pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType();
5453                success = true;
5454                break;
5455
5456            case clang::Type::Typedef:
5457                return ClangASTContext::IsPossibleDynamicType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), dynamic_pointee_type);
5458
5459            case clang::Type::Elaborated:
5460                return ClangASTContext::IsPossibleDynamicType (ast, cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), dynamic_pointee_type);
5461
5462            default:
5463                break;
5464        }
5465
5466        if (success)
5467        {
5468            // Check to make sure what we are pointing too is a possible dynamic C++ type
5469            // We currently accept any "void *" (in case we have a class that has been
5470            // watered down to an opaque pointer) and virtual C++ classes.
5471            const clang::Type::TypeClass pointee_type_class = pointee_qual_type->getTypeClass();
5472            switch (pointee_type_class)
5473            {
5474                case clang::Type::Builtin:
5475                    switch (cast<clang::BuiltinType>(pointee_qual_type)->getKind())
5476                    {
5477                        case clang::BuiltinType::UnknownAny:
5478                        case clang::BuiltinType::Void:
5479                            if (dynamic_pointee_type)
5480                                *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
5481                            return true;
5482
5483                        case clang::BuiltinType::NullPtr:
5484                        case clang::BuiltinType::Bool:
5485                        case clang::BuiltinType::Char_U:
5486                        case clang::BuiltinType::UChar:
5487                        case clang::BuiltinType::WChar_U:
5488                        case clang::BuiltinType::Char16:
5489                        case clang::BuiltinType::Char32:
5490                        case clang::BuiltinType::UShort:
5491                        case clang::BuiltinType::UInt:
5492                        case clang::BuiltinType::ULong:
5493                        case clang::BuiltinType::ULongLong:
5494                        case clang::BuiltinType::UInt128:
5495                        case clang::BuiltinType::Char_S:
5496                        case clang::BuiltinType::SChar:
5497                        case clang::BuiltinType::WChar_S:
5498                        case clang::BuiltinType::Short:
5499                        case clang::BuiltinType::Int:
5500                        case clang::BuiltinType::Long:
5501                        case clang::BuiltinType::LongLong:
5502                        case clang::BuiltinType::Int128:
5503                        case clang::BuiltinType::Float:
5504                        case clang::BuiltinType::Double:
5505                        case clang::BuiltinType::LongDouble:
5506                        case clang::BuiltinType::Dependent:
5507                        case clang::BuiltinType::Overload:
5508                        case clang::BuiltinType::ObjCId:
5509                        case clang::BuiltinType::ObjCClass:
5510                        case clang::BuiltinType::ObjCSel:
5511                        case clang::BuiltinType::BoundMember:
5512                        case clang::BuiltinType::Half:
5513                        case clang::BuiltinType::ARCUnbridgedCast:
5514                        case clang::BuiltinType::PseudoObject:
5515                            break;
5516                    }
5517                    break;
5518
5519                case clang::Type::Record:
5520                    if (check_cplusplus)
5521                    {
5522                        CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
5523                        if (cxx_record_decl)
5524                        {
5525                            // Do NOT complete the type here like we used to do
5526                            // otherwise EVERY "class *" variable we have will try
5527                            // to fully complete itself and this will take a lot of
5528                            // time, memory and slow down debugging. If we have a complete
5529                            // type, then answer the question definitively, else we
5530                            // just say that a C++ class can possibly be dynamic...
5531                            if (cxx_record_decl->isCompleteDefinition())
5532                            {
5533                                success = cxx_record_decl->isDynamicClass();
5534                            }
5535                            else
5536                            {
5537                                // We failed to get the complete type, so we have to
5538                                // treat this as a void * which we might possibly be
5539                                // able to complete
5540                                success = true;
5541                            }
5542                            if (success)
5543                            {
5544                                if (dynamic_pointee_type)
5545                                    *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
5546                                return true;
5547                            }
5548                        }
5549                    }
5550                    break;
5551
5552                case clang::Type::ObjCObject:
5553                case clang::Type::ObjCInterface:
5554                    if (check_objc)
5555                    {
5556                        if (dynamic_pointee_type)
5557                            *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
5558                        return true;
5559                    }
5560                    break;
5561
5562                default:
5563                    break;
5564            }
5565        }
5566    }
5567    if (dynamic_pointee_type)
5568        *dynamic_pointee_type = NULL;
5569    return false;
5570}
5571
5572
5573bool
5574ClangASTContext::IsPossibleCPlusPlusDynamicType (clang::ASTContext *ast, clang_type_t clang_type, clang_type_t *dynamic_pointee_type)
5575{
5576    return IsPossibleDynamicType (ast,
5577                                  clang_type,
5578                                  dynamic_pointee_type,
5579                                  true,     // Check for dynamic C++ types
5580                                  false);   // Check for dynamic ObjC types
5581}
5582
5583bool
5584ClangASTContext::IsReferenceType (clang_type_t clang_type, clang_type_t *target_type)
5585{
5586    if (clang_type == NULL)
5587        return false;
5588
5589    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5590    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5591
5592    switch (type_class)
5593    {
5594    case clang::Type::LValueReference:
5595        if (target_type)
5596            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
5597        return true;
5598    case clang::Type::RValueReference:
5599        if (target_type)
5600            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
5601        return true;
5602    case clang::Type::Typedef:
5603        return ClangASTContext::IsReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
5604    case clang::Type::Elaborated:
5605        return ClangASTContext::IsReferenceType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
5606    default:
5607        break;
5608    }
5609
5610    return false;
5611}
5612
5613bool
5614ClangASTContext::IsPointerOrReferenceType (clang_type_t clang_type, clang_type_t*target_type)
5615{
5616    if (clang_type == NULL)
5617        return false;
5618
5619    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5620    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5621    switch (type_class)
5622    {
5623    case clang::Type::Builtin:
5624        switch (cast<clang::BuiltinType>(qual_type)->getKind())
5625        {
5626        default:
5627            break;
5628        case clang::BuiltinType::ObjCId:
5629        case clang::BuiltinType::ObjCClass:
5630            return true;
5631        }
5632        return false;
5633    case clang::Type::ObjCObjectPointer:
5634        if (target_type)
5635            *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5636        return true;
5637    case clang::Type::BlockPointer:
5638        if (target_type)
5639            *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5640        return true;
5641    case clang::Type::Pointer:
5642        if (target_type)
5643            *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5644        return true;
5645    case clang::Type::MemberPointer:
5646        if (target_type)
5647            *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5648        return true;
5649    case clang::Type::LValueReference:
5650        if (target_type)
5651            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
5652        return true;
5653    case clang::Type::RValueReference:
5654        if (target_type)
5655            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
5656        return true;
5657    case clang::Type::Typedef:
5658        return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
5659    case clang::Type::Elaborated:
5660        return ClangASTContext::IsPointerOrReferenceType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
5661    default:
5662        break;
5663    }
5664    return false;
5665}
5666
5667bool
5668ClangASTContext::IsIntegerType (clang_type_t clang_type, bool &is_signed)
5669{
5670    if (!clang_type)
5671        return false;
5672
5673    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5674    const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
5675
5676    if (builtin_type)
5677    {
5678        if (builtin_type->isInteger())
5679        {
5680            is_signed = builtin_type->isSignedInteger();
5681            return true;
5682        }
5683    }
5684
5685    return false;
5686}
5687
5688bool
5689ClangASTContext::IsPointerType (clang_type_t clang_type, clang_type_t *target_type)
5690{
5691    if (target_type)
5692        *target_type = NULL;
5693
5694    if (clang_type)
5695    {
5696        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5697        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5698        switch (type_class)
5699        {
5700        case clang::Type::Builtin:
5701            switch (cast<clang::BuiltinType>(qual_type)->getKind())
5702            {
5703            default:
5704                break;
5705            case clang::BuiltinType::ObjCId:
5706            case clang::BuiltinType::ObjCClass:
5707                return true;
5708            }
5709            return false;
5710        case clang::Type::ObjCObjectPointer:
5711            if (target_type)
5712                *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5713            return true;
5714        case clang::Type::BlockPointer:
5715            if (target_type)
5716                *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5717            return true;
5718        case clang::Type::Pointer:
5719            if (target_type)
5720                *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5721            return true;
5722        case clang::Type::MemberPointer:
5723            if (target_type)
5724                *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
5725            return true;
5726        case clang::Type::Typedef:
5727            return ClangASTContext::IsPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), target_type);
5728        case clang::Type::Elaborated:
5729            return ClangASTContext::IsPointerType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(), target_type);
5730        default:
5731            break;
5732        }
5733    }
5734    return false;
5735}
5736
5737bool
5738ClangASTContext::IsFloatingPointType (clang_type_t clang_type, uint32_t &count, bool &is_complex)
5739{
5740    if (clang_type)
5741    {
5742        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5743
5744        if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
5745        {
5746            clang::BuiltinType::Kind kind = BT->getKind();
5747            if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
5748            {
5749                count = 1;
5750                is_complex = false;
5751                return true;
5752            }
5753        }
5754        else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
5755        {
5756            if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, is_complex))
5757            {
5758                count = 2;
5759                is_complex = true;
5760                return true;
5761            }
5762        }
5763        else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
5764        {
5765            if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, is_complex))
5766            {
5767                count = VT->getNumElements();
5768                is_complex = false;
5769                return true;
5770            }
5771        }
5772    }
5773    return false;
5774}
5775
5776bool
5777ClangASTContext::IsScalarType (lldb::clang_type_t clang_type)
5778{
5779    bool is_signed;
5780    if (ClangASTContext::IsIntegerType(clang_type, is_signed))
5781        return true;
5782
5783    uint32_t count;
5784    bool is_complex;
5785    return ClangASTContext::IsFloatingPointType(clang_type, count, is_complex) && !is_complex;
5786}
5787
5788bool
5789ClangASTContext::IsPointerToScalarType (lldb::clang_type_t clang_type)
5790{
5791    if (!IsPointerType(clang_type))
5792        return false;
5793
5794    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5795    lldb::clang_type_t pointee_type = qual_type.getTypePtr()->getPointeeType().getAsOpaquePtr();
5796    return IsScalarType(pointee_type);
5797}
5798
5799bool
5800ClangASTContext::IsArrayOfScalarType (lldb::clang_type_t clang_type)
5801{
5802    clang_type = GetAsArrayType(clang_type);
5803
5804    if (clang_type == 0)
5805        return false;
5806
5807    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5808    lldb::clang_type_t item_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
5809    return IsScalarType(item_type);
5810}
5811
5812
5813bool
5814ClangASTContext::GetCXXClassName (clang_type_t clang_type, std::string &class_name)
5815{
5816    if (clang_type)
5817    {
5818        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5819
5820        CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
5821        if (cxx_record_decl)
5822        {
5823            class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
5824            return true;
5825        }
5826    }
5827    class_name.clear();
5828    return false;
5829}
5830
5831
5832bool
5833ClangASTContext::IsCXXClassType (clang_type_t clang_type)
5834{
5835    if (clang_type)
5836    {
5837        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5838        if (qual_type->getAsCXXRecordDecl() != NULL)
5839            return true;
5840    }
5841    return false;
5842}
5843
5844bool
5845ClangASTContext::IsBeingDefined (lldb::clang_type_t clang_type)
5846{
5847    if (clang_type)
5848    {
5849        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5850        const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type);
5851        if (tag_type)
5852            return tag_type->isBeingDefined();
5853    }
5854    return false;
5855}
5856
5857bool
5858ClangASTContext::IsObjCClassType (clang_type_t clang_type)
5859{
5860    if (clang_type)
5861    {
5862        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5863        if (qual_type->isObjCObjectOrInterfaceType())
5864            return true;
5865    }
5866    return false;
5867}
5868
5869bool
5870ClangASTContext::IsObjCObjectPointerType (lldb::clang_type_t clang_type, clang_type_t *class_type)
5871{
5872    if (clang_type)
5873    {
5874        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5875        if (qual_type->isObjCObjectPointerType())
5876        {
5877            if (class_type)
5878            {
5879                *class_type = NULL;
5880
5881                if (!qual_type->isObjCClassType() &&
5882                    !qual_type->isObjCIdType())
5883                {
5884                    const ObjCObjectPointerType *obj_pointer_type = dyn_cast<ObjCObjectPointerType>(qual_type);
5885                    if (!obj_pointer_type)
5886                        *class_type = NULL;
5887                    else
5888                        *class_type = QualType(obj_pointer_type->getInterfaceType(), 0).getAsOpaquePtr();
5889                }
5890            }
5891            return true;
5892        }
5893    }
5894    return false;
5895}
5896
5897bool
5898ClangASTContext::GetObjCClassName (lldb::clang_type_t clang_type,
5899                                   std::string &class_name)
5900{
5901    if (!clang_type)
5902        return false;
5903
5904    const ObjCObjectType *object_type = dyn_cast<ObjCObjectType>(QualType::getFromOpaquePtr(clang_type));
5905    if (!object_type)
5906        return false;
5907
5908    const ObjCInterfaceDecl *interface = object_type->getInterface();
5909    if (!interface)
5910        return false;
5911
5912    class_name = interface->getNameAsString();
5913    return true;
5914}
5915
5916bool
5917ClangASTContext::IsCharType (clang_type_t clang_type)
5918{
5919    if (clang_type)
5920        return QualType::getFromOpaquePtr(clang_type)->isCharType();
5921    return false;
5922}
5923
5924bool
5925ClangASTContext::IsCStringType (clang_type_t clang_type, uint32_t &length)
5926{
5927    clang_type_t pointee_or_element_clang_type = NULL;
5928    Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, &pointee_or_element_clang_type));
5929
5930    if (pointee_or_element_clang_type == NULL)
5931        return false;
5932
5933    if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
5934    {
5935        QualType pointee_or_element_qual_type (QualType::getFromOpaquePtr (pointee_or_element_clang_type));
5936
5937        if (pointee_or_element_qual_type.getUnqualifiedType()->isCharType())
5938        {
5939            QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5940            if (type_flags.Test (eTypeIsArray))
5941            {
5942                // We know the size of the array and it could be a C string
5943                // since it is an array of characters
5944                length = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
5945                return true;
5946            }
5947            else
5948            {
5949                length = 0;
5950                return true;
5951            }
5952
5953        }
5954    }
5955    return false;
5956}
5957
5958bool
5959ClangASTContext::IsFunctionPointerType (clang_type_t clang_type)
5960{
5961    if (clang_type)
5962    {
5963        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
5964
5965        if (qual_type->isFunctionPointerType())
5966            return true;
5967
5968        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5969        switch (type_class)
5970        {
5971        default:
5972            break;
5973        case clang::Type::Typedef:
5974            return ClangASTContext::IsFunctionPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
5975        case clang::Type::Elaborated:
5976            return ClangASTContext::IsFunctionPointerType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
5977
5978        case clang::Type::LValueReference:
5979        case clang::Type::RValueReference:
5980            {
5981                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
5982                if (reference_type)
5983                    return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr());
5984            }
5985            break;
5986        }
5987    }
5988    return false;
5989}
5990
5991size_t
5992ClangASTContext::GetArraySize (clang_type_t clang_type)
5993{
5994    if (clang_type)
5995    {
5996        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
5997        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
5998        switch (type_class)
5999        {
6000        case clang::Type::ConstantArray:
6001            {
6002                const ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
6003                if (array)
6004                    return array->getSize().getLimitedValue();
6005            }
6006            break;
6007
6008        case clang::Type::Typedef:
6009            return ClangASTContext::GetArraySize(cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
6010
6011        case clang::Type::Elaborated:
6012            return ClangASTContext::GetArraySize(cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr());
6013
6014        default:
6015            break;
6016        }
6017    }
6018    return 0;
6019}
6020
6021clang_type_t
6022ClangASTContext::GetAsArrayType (clang_type_t clang_type, clang_type_t*member_type, uint64_t *size)
6023{
6024    if (!clang_type)
6025        return 0;
6026
6027    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
6028
6029    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
6030    switch (type_class)
6031    {
6032    default:
6033        break;
6034
6035    case clang::Type::ConstantArray:
6036        if (member_type)
6037            *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr();
6038        if (size)
6039            *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
6040        return clang_type;
6041
6042    case clang::Type::IncompleteArray:
6043        if (member_type)
6044            *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr();
6045        if (size)
6046            *size = 0;
6047        return clang_type;
6048
6049    case clang::Type::VariableArray:
6050        if (member_type)
6051            *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr();
6052        if (size)
6053            *size = 0;
6054        return clang_type;
6055
6056    case clang::Type::DependentSizedArray:
6057        if (member_type)
6058            *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr();
6059        if (size)
6060            *size = 0;
6061        return clang_type;
6062
6063    case clang::Type::Typedef:
6064        return ClangASTContext::GetAsArrayType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
6065                                                member_type,
6066                                                size);
6067
6068    case clang::Type::Elaborated:
6069        return ClangASTContext::GetAsArrayType (cast<ElaboratedType>(qual_type)->getNamedType().getAsOpaquePtr(),
6070                                                member_type,
6071                                                size);
6072    }
6073    return 0;
6074}
6075
6076
6077#pragma mark Typedefs
6078
6079clang_type_t
6080ClangASTContext::CreateTypedefType (const char *name, clang_type_t clang_type, DeclContext *decl_ctx)
6081{
6082    if (clang_type)
6083    {
6084        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
6085        ASTContext *ast = getASTContext();
6086        IdentifierTable *identifier_table = getIdentifierTable();
6087        assert (ast != NULL);
6088        assert (identifier_table != NULL);
6089        if (decl_ctx == NULL)
6090            decl_ctx = ast->getTranslationUnitDecl();
6091        TypedefDecl *decl = TypedefDecl::Create (*ast,
6092                                                 decl_ctx,
6093                                                 SourceLocation(),
6094                                                 SourceLocation(),
6095                                                 name ? &identifier_table->get(name) : NULL, // Identifier
6096                                                 ast->CreateTypeSourceInfo(qual_type));
6097
6098        //decl_ctx->addDecl (decl);
6099
6100        decl->setAccess(AS_public); // TODO respect proper access specifier
6101
6102        // Get a uniqued QualType for the typedef decl type
6103        return ast->getTypedefType (decl).getAsOpaquePtr();
6104    }
6105    return NULL;
6106}
6107
6108// Disable this for now since I can't seem to get a nicely formatted float
6109// out of the APFloat class without just getting the float, double or quad
6110// and then using a formatted print on it which defeats the purpose. We ideally
6111// would like to get perfect string values for any kind of float semantics
6112// so we can support remote targets. The code below also requires a patch to
6113// llvm::APInt.
6114//bool
6115//ClangASTContext::ConvertFloatValueToString (ASTContext *ast, clang_type_t clang_type, const uint8_t* bytes, size_t byte_size, int apint_byte_order, std::string &float_str)
6116//{
6117//  uint32_t count = 0;
6118//  bool is_complex = false;
6119//  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
6120//  {
6121//      unsigned num_bytes_per_float = byte_size / count;
6122//      unsigned num_bits_per_float = num_bytes_per_float * 8;
6123//
6124//      float_str.clear();
6125//      uint32_t i;
6126//      for (i=0; i<count; i++)
6127//      {
6128//          APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
6129//          bool is_ieee = false;
6130//          APFloat ap_float(ap_int, is_ieee);
6131//          char s[1024];
6132//          unsigned int hex_digits = 0;
6133//          bool upper_case = false;
6134//
6135//          if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
6136//          {
6137//              if (i > 0)
6138//                  float_str.append(", ");
6139//              float_str.append(s);
6140//              if (i == 1 && is_complex)
6141//                  float_str.append(1, 'i');
6142//          }
6143//      }
6144//      return !float_str.empty();
6145//  }
6146//  return false;
6147//}
6148
6149size_t
6150ClangASTContext::ConvertStringToFloatValue (ASTContext *ast, clang_type_t clang_type, const char *s, uint8_t *dst, size_t dst_size)
6151{
6152    if (clang_type)
6153    {
6154        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
6155        uint32_t count = 0;
6156        bool is_complex = false;
6157        if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
6158        {
6159            // TODO: handle complex and vector types
6160            if (count != 1)
6161                return false;
6162
6163            StringRef s_sref(s);
6164            APFloat ap_float(ast->getFloatTypeSemantics(qual_type), s_sref);
6165
6166            const uint64_t bit_size = ast->getTypeSize (qual_type);
6167            const uint64_t byte_size = bit_size / 8;
6168            if (dst_size >= byte_size)
6169            {
6170                if (bit_size == sizeof(float)*8)
6171                {
6172                    float float32 = ap_float.convertToFloat();
6173                    ::memcpy (dst, &float32, byte_size);
6174                    return byte_size;
6175                }
6176                else if (bit_size >= 64)
6177                {
6178                    llvm::APInt ap_int(ap_float.bitcastToAPInt());
6179                    ::memcpy (dst, ap_int.getRawData(), byte_size);
6180                    return byte_size;
6181                }
6182            }
6183        }
6184    }
6185    return 0;
6186}
6187
6188unsigned
6189ClangASTContext::GetTypeQualifiers(clang_type_t clang_type)
6190{
6191    assert (clang_type);
6192
6193    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
6194
6195    return qual_type.getQualifiers().getCVRQualifiers();
6196}
6197
6198uint64_t
6199GetTypeFlags(clang::ASTContext *ast, lldb::clang_type_t clang_type)
6200{
6201    assert (clang_type);
6202
6203    clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
6204
6205    if (!external_ast_source)
6206        return 0;
6207
6208    ClangExternalASTSourceCommon *common_ast_source = static_cast<ClangExternalASTSourceCommon*>(external_ast_source);
6209
6210    return common_ast_source->GetMetadata((uintptr_t)clang_type);
6211}
6212
6213void
6214SetTypeFlags(clang::ASTContext *ast, lldb::clang_type_t clang_type, uint64_t flags)
6215{
6216    assert (clang_type);
6217
6218    clang::ExternalASTSource *external_ast_source = ast->getExternalSource();
6219
6220    if (!external_ast_source)
6221        return;
6222
6223    ClangExternalASTSourceCommon *common_ast_source = static_cast<ClangExternalASTSourceCommon*>(external_ast_source);
6224
6225    return common_ast_source->SetMetadata((uintptr_t)clang_type, flags);
6226}
6227
6228bool
6229ClangASTContext::GetCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type)
6230{
6231    if (clang_type == NULL)
6232        return false;
6233
6234    return GetCompleteQualType (ast, clang::QualType::getFromOpaquePtr(clang_type));
6235}
6236
6237
6238bool
6239ClangASTContext::GetCompleteType (clang_type_t clang_type)
6240{
6241    return ClangASTContext::GetCompleteType (getASTContext(), clang_type);
6242}
6243
6244bool
6245ClangASTContext::IsCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type)
6246{
6247    if (clang_type == NULL)
6248        return false;
6249
6250    return GetCompleteQualType (ast, clang::QualType::getFromOpaquePtr(clang_type), false); // just check but don't let it actually complete
6251}
6252
6253
6254bool
6255ClangASTContext::IsCompleteType (clang_type_t clang_type)
6256{
6257    return ClangASTContext::IsCompleteType (getASTContext(), clang_type);
6258}
6259
6260bool
6261ClangASTContext::GetCompleteDecl (clang::ASTContext *ast,
6262                                  clang::Decl *decl)
6263{
6264    if (!decl)
6265        return false;
6266
6267    ExternalASTSource *ast_source = ast->getExternalSource();
6268
6269    if (!ast_source)
6270        return false;
6271
6272    if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
6273    {
6274        if (tag_decl->isCompleteDefinition())
6275            return true;
6276
6277        if (!tag_decl->hasExternalLexicalStorage())
6278            return false;
6279
6280        ast_source->CompleteType(tag_decl);
6281
6282        return !tag_decl->getTypeForDecl()->isIncompleteType();
6283    }
6284    else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
6285    {
6286        if (objc_interface_decl->getDefinition())
6287            return true;
6288
6289        if (!objc_interface_decl->hasExternalLexicalStorage())
6290            return false;
6291
6292        ast_source->CompleteType(objc_interface_decl);
6293
6294        return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
6295    }
6296    else
6297    {
6298        return false;
6299    }
6300}
6301
6302clang::DeclContext *
6303ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl)
6304{
6305    return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl);
6306}
6307
6308clang::DeclContext *
6309ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl)
6310{
6311    return llvm::dyn_cast<clang::DeclContext>(objc_method_decl);
6312}
6313
6314