ClangASTContext.cpp revision a83f8779ac614263d92959d2338e6e9f08d8f9fb 
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#ifndef NDEBUG
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/RecordLayout.h"
40#include "clang/AST/Type.h"
41#include "clang/Basic/Builtins.h"
42#include "clang/Basic/FileManager.h"
43#include "clang/Basic/FileSystemOptions.h"
44#include "clang/Basic/SourceManager.h"
45#include "clang/Basic/TargetInfo.h"
46#include "clang/Basic/TargetOptions.h"
47#include "clang/Frontend/FrontendOptions.h"
48#include "clang/Frontend/LangStandard.h"
49
50#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
51#undef NDEBUG
52#undef LLDB_DEFINED_NDEBUG_FOR_CLANG
53// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
54#include <assert.h>
55#endif
56
57#include "lldb/Core/ArchSpec.h"
58#include "lldb/Core/dwarf.h"
59#include "lldb/Core/Flags.h"
60#include "lldb/Core/Log.h"
61#include "lldb/Target/ExecutionContext.h"
62#include "lldb/Target/Process.h"
63#include "lldb/Target/ObjCLanguageRuntime.h"
64
65
66#include <stdio.h>
67
68using namespace lldb;
69using namespace lldb_private;
70using namespace llvm;
71using namespace clang;
72
73
74static bool
75GetCompleteQualType (clang::ASTContext *ast, clang::QualType qual_type)
76{
77    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
78    switch (type_class)
79    {
80    case clang::Type::Record:
81    case clang::Type::Enum:
82        {
83            const clang::TagType *tag_type = dyn_cast<clang::TagType>(qual_type.getTypePtr());
84            if (tag_type)
85            {
86                clang::TagDecl *tag_decl = tag_type->getDecl();
87                if (tag_decl)
88                {
89                    if (tag_decl->getDefinition())
90                        return true;
91
92                    if (tag_decl->hasExternalLexicalStorage())
93                    {
94                        if (ast)
95                        {
96                            ExternalASTSource *external_ast_source = ast->getExternalSource();
97                            if (external_ast_source)
98                            {
99                                external_ast_source->CompleteType(tag_decl);
100                                return !tag_type->isIncompleteType();
101                            }
102                        }
103                    }
104                    return false;
105                }
106            }
107
108        }
109        break;
110
111    case clang::Type::ObjCObject:
112    case clang::Type::ObjCInterface:
113        {
114            const clang::ObjCObjectType *objc_class_type = dyn_cast<clang::ObjCObjectType>(qual_type);
115            if (objc_class_type)
116            {
117                clang::ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
118                // We currently can't complete objective C types through the newly added ASTContext
119                // because it only supports TagDecl objects right now...
120                if (class_interface_decl)
121                {
122                    bool is_forward_decl = class_interface_decl->isForwardDecl();
123                    if (is_forward_decl && class_interface_decl->hasExternalLexicalStorage())
124                    {
125                        if (ast)
126                        {
127                            ExternalASTSource *external_ast_source = ast->getExternalSource();
128                            if (external_ast_source)
129                            {
130                                external_ast_source->CompleteType (class_interface_decl);
131                                is_forward_decl = class_interface_decl->isForwardDecl();
132                            }
133                        }
134                        return is_forward_decl == false;
135                    }
136                    return true;
137                }
138                else
139                    return false;
140            }
141        }
142        break;
143
144    case clang::Type::Typedef:
145        return GetCompleteQualType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType());
146
147    default:
148        break;
149    }
150
151    return true;
152}
153
154
155static AccessSpecifier
156ConvertAccessTypeToAccessSpecifier (AccessType access)
157{
158    switch (access)
159    {
160    default:               break;
161    case eAccessNone:      return AS_none;
162    case eAccessPublic:    return AS_public;
163    case eAccessPrivate:   return AS_private;
164    case eAccessProtected: return AS_protected;
165    }
166    return AS_none;
167}
168
169static ObjCIvarDecl::AccessControl
170ConvertAccessTypeToObjCIvarAccessControl (AccessType access)
171{
172    switch (access)
173    {
174    default:               break;
175    case eAccessNone:      return ObjCIvarDecl::None;
176    case eAccessPublic:    return ObjCIvarDecl::Public;
177    case eAccessPrivate:   return ObjCIvarDecl::Private;
178    case eAccessProtected: return ObjCIvarDecl::Protected;
179    case eAccessPackage:   return ObjCIvarDecl::Package;
180    }
181    return ObjCIvarDecl::None;
182}
183
184
185static void
186ParseLangArgs
187(
188    LangOptions &Opts,
189    InputKind IK
190)
191{
192    // FIXME: Cleanup per-file based stuff.
193
194    // Set some properties which depend soley on the input kind; it would be nice
195    // to move these to the language standard, and have the driver resolve the
196    // input kind + language standard.
197    if (IK == IK_Asm) {
198        Opts.AsmPreprocessor = 1;
199    } else if (IK == IK_ObjC ||
200               IK == IK_ObjCXX ||
201               IK == IK_PreprocessedObjC ||
202               IK == IK_PreprocessedObjCXX) {
203        Opts.ObjC1 = Opts.ObjC2 = 1;
204    }
205
206    LangStandard::Kind LangStd = LangStandard::lang_unspecified;
207
208    if (LangStd == LangStandard::lang_unspecified) {
209        // Based on the base language, pick one.
210        switch (IK) {
211            case IK_None:
212            case IK_AST:
213            case IK_LLVM_IR:
214                assert (!"Invalid input kind!");
215            case IK_OpenCL:
216                LangStd = LangStandard::lang_opencl;
217                break;
218            case IK_CUDA:
219                LangStd = LangStandard::lang_cuda;
220                break;
221            case IK_Asm:
222            case IK_C:
223            case IK_PreprocessedC:
224            case IK_ObjC:
225            case IK_PreprocessedObjC:
226                LangStd = LangStandard::lang_gnu99;
227                break;
228            case IK_CXX:
229            case IK_PreprocessedCXX:
230            case IK_ObjCXX:
231            case IK_PreprocessedObjCXX:
232                LangStd = LangStandard::lang_gnucxx98;
233                break;
234        }
235    }
236
237    const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
238    Opts.BCPLComment = Std.hasBCPLComments();
239    Opts.C99 = Std.isC99();
240    Opts.CPlusPlus = Std.isCPlusPlus();
241    Opts.CPlusPlus0x = Std.isCPlusPlus0x();
242    Opts.Digraphs = Std.hasDigraphs();
243    Opts.GNUMode = Std.isGNUMode();
244    Opts.GNUInline = !Std.isC99();
245    Opts.HexFloats = Std.hasHexFloats();
246    Opts.ImplicitInt = Std.hasImplicitInt();
247
248    // OpenCL has some additional defaults.
249    if (LangStd == LangStandard::lang_opencl) {
250        Opts.OpenCL = 1;
251        Opts.AltiVec = 1;
252        Opts.CXXOperatorNames = 1;
253        Opts.LaxVectorConversions = 1;
254    }
255
256    // OpenCL and C++ both have bool, true, false keywords.
257    Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
258
259//    if (Opts.CPlusPlus)
260//        Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
261//
262//    if (Args.hasArg(OPT_fobjc_gc_only))
263//        Opts.setGCMode(LangOptions::GCOnly);
264//    else if (Args.hasArg(OPT_fobjc_gc))
265//        Opts.setGCMode(LangOptions::HybridGC);
266//
267//    if (Args.hasArg(OPT_print_ivar_layout))
268//        Opts.ObjCGCBitmapPrint = 1;
269//
270//    if (Args.hasArg(OPT_faltivec))
271//        Opts.AltiVec = 1;
272//
273//    if (Args.hasArg(OPT_pthread))
274//        Opts.POSIXThreads = 1;
275//
276//    llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
277//                                          "default");
278//    if (Vis == "default")
279        Opts.setVisibilityMode(DefaultVisibility);
280//    else if (Vis == "hidden")
281//        Opts.setVisibilityMode(LangOptions::Hidden);
282//    else if (Vis == "protected")
283//        Opts.setVisibilityMode(LangOptions::Protected);
284//    else
285//        Diags.Report(diag::err_drv_invalid_value)
286//        << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
287
288//    Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
289
290    // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
291    // is specified, or -std is set to a conforming mode.
292    Opts.Trigraphs = !Opts.GNUMode;
293//    if (Args.hasArg(OPT_trigraphs))
294//        Opts.Trigraphs = 1;
295//
296//    Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
297//                                     OPT_fno_dollars_in_identifiers,
298//                                     !Opts.AsmPreprocessor);
299//    Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
300//    Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
301//    Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
302//    if (Args.hasArg(OPT_fno_lax_vector_conversions))
303//        Opts.LaxVectorConversions = 0;
304//    Opts.Exceptions = Args.hasArg(OPT_fexceptions);
305//    Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
306//    Opts.Blocks = Args.hasArg(OPT_fblocks);
307//    Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
308//    Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
309//    Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
310//    Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
311//    Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
312//    Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
313//    Opts.AccessControl = Args.hasArg(OPT_faccess_control);
314//    Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
315//    Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
316//    Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
317//                                                 Diags);
318//    Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
319//    Opts.ObjCConstantStringClass = getLastArgValue(Args,
320//                                                   OPT_fconstant_string_class);
321//    Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
322//    Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
323//    Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
324//    Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
325//    Opts.Static = Args.hasArg(OPT_static_define);
326    Opts.OptimizeSize = 0;
327
328    // FIXME: Eliminate this dependency.
329//    unsigned Opt =
330//    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
331//    Opts.Optimize = Opt != 0;
332    unsigned Opt = 0;
333
334    // This is the __NO_INLINE__ define, which just depends on things like the
335    // optimization level and -fno-inline, not actually whether the backend has
336    // inlining enabled.
337    //
338    // FIXME: This is affected by other options (-fno-inline).
339    Opts.NoInline = !Opt;
340
341//    unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
342//    switch (SSP) {
343//        default:
344//            Diags.Report(diag::err_drv_invalid_value)
345//            << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
346//            break;
347//        case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
348//        case 1: Opts.setStackProtectorMode(LangOptions::SSPOn);  break;
349//        case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
350//    }
351}
352
353
354ClangASTContext::ClangASTContext (const char *target_triple) :
355    m_target_triple(),
356    m_ast_ap(),
357    m_language_options_ap(),
358    m_source_manager_ap(),
359    m_diagnostic_ap(),
360    m_target_options_ap(),
361    m_target_info_ap(),
362    m_identifier_table_ap(),
363    m_selector_table_ap(),
364    m_builtins_ap(),
365    m_callback_tag_decl (NULL),
366    m_callback_objc_decl (NULL),
367    m_callback_baton (NULL)
368
369{
370    if (target_triple && target_triple[0])
371        SetTargetTriple (target_triple);
372}
373
374//----------------------------------------------------------------------
375// Destructor
376//----------------------------------------------------------------------
377ClangASTContext::~ClangASTContext()
378{
379    m_builtins_ap.reset();
380    m_selector_table_ap.reset();
381    m_identifier_table_ap.reset();
382    m_target_info_ap.reset();
383    m_target_options_ap.reset();
384    m_diagnostic_ap.reset();
385    m_source_manager_ap.reset();
386    m_language_options_ap.reset();
387    m_ast_ap.reset();
388}
389
390
391void
392ClangASTContext::Clear()
393{
394    m_ast_ap.reset();
395    m_language_options_ap.reset();
396    m_source_manager_ap.reset();
397    m_diagnostic_ap.reset();
398    m_target_options_ap.reset();
399    m_target_info_ap.reset();
400    m_identifier_table_ap.reset();
401    m_selector_table_ap.reset();
402    m_builtins_ap.reset();
403}
404
405const char *
406ClangASTContext::GetTargetTriple ()
407{
408    return m_target_triple.c_str();
409}
410
411void
412ClangASTContext::SetTargetTriple (const char *target_triple)
413{
414    Clear();
415    m_target_triple.assign(target_triple);
416    if (m_target_triple.find("armv7s") == 0)
417        m_target_triple.erase(5,1);
418    else if (m_target_triple.find("armv7f") == 0)
419        m_target_triple.erase(5,1);
420    else if (m_target_triple.find("armv7k") == 0)
421        m_target_triple.erase(5,1);
422}
423
424void
425ClangASTContext::SetArchitecture (const ArchSpec &arch)
426{
427    SetTargetTriple(arch.GetTriple().str().c_str());
428}
429
430bool
431ClangASTContext::HasExternalSource ()
432{
433    ASTContext *ast = getASTContext();
434    if (ast)
435        return ast->getExternalSource () != NULL;
436    return false;
437}
438
439void
440ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap)
441{
442    ASTContext *ast = getASTContext();
443    if (ast)
444    {
445        ast->setExternalSource (ast_source_ap);
446        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
447        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
448    }
449}
450
451void
452ClangASTContext::RemoveExternalSource ()
453{
454    ASTContext *ast = getASTContext();
455
456    if (ast)
457    {
458        llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap;
459        ast->setExternalSource (empty_ast_source_ap);
460        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
461        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
462    }
463}
464
465
466
467ASTContext *
468ClangASTContext::getASTContext()
469{
470    if (m_ast_ap.get() == NULL)
471    {
472        m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
473                                       *getSourceManager(),
474                                       *getTargetInfo(),
475                                       *getIdentifierTable(),
476                                       *getSelectorTable(),
477                                       *getBuiltinContext(),
478                                       0));
479
480        if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
481        {
482            m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
483            //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
484        }
485
486        m_ast_ap->getDiagnostics().setClient(getDiagnosticClient(), false);
487    }
488    return m_ast_ap.get();
489}
490
491Builtin::Context *
492ClangASTContext::getBuiltinContext()
493{
494    if (m_builtins_ap.get() == NULL)
495        m_builtins_ap.reset (new Builtin::Context(*getTargetInfo()));
496    return m_builtins_ap.get();
497}
498
499IdentifierTable *
500ClangASTContext::getIdentifierTable()
501{
502    if (m_identifier_table_ap.get() == NULL)
503        m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL));
504    return m_identifier_table_ap.get();
505}
506
507LangOptions *
508ClangASTContext::getLanguageOptions()
509{
510    if (m_language_options_ap.get() == NULL)
511    {
512        m_language_options_ap.reset(new LangOptions());
513        ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
514//        InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
515    }
516    return m_language_options_ap.get();
517}
518
519SelectorTable *
520ClangASTContext::getSelectorTable()
521{
522    if (m_selector_table_ap.get() == NULL)
523        m_selector_table_ap.reset (new SelectorTable());
524    return m_selector_table_ap.get();
525}
526
527clang::FileManager *
528ClangASTContext::getFileManager()
529{
530    if (m_file_manager_ap.get() == NULL)
531    {
532        clang::FileSystemOptions file_system_options;
533        m_file_manager_ap.reset(new clang::FileManager(file_system_options));
534    }
535    return m_file_manager_ap.get();
536}
537
538clang::SourceManager *
539ClangASTContext::getSourceManager()
540{
541    if (m_source_manager_ap.get() == NULL)
542        m_source_manager_ap.reset(new clang::SourceManager(*getDiagnostic(), *getFileManager()));
543    return m_source_manager_ap.get();
544}
545
546Diagnostic *
547ClangASTContext::getDiagnostic()
548{
549    if (m_diagnostic_ap.get() == NULL)
550    {
551        llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
552        m_diagnostic_ap.reset(new Diagnostic(diag_id_sp));
553    }
554    return m_diagnostic_ap.get();
555}
556
557class NullDiagnosticClient : public DiagnosticClient
558{
559public:
560    NullDiagnosticClient ()
561    {
562        m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
563    }
564
565    void HandleDiagnostic (Diagnostic::Level DiagLevel, const DiagnosticInfo &info)
566    {
567        if (m_log)
568        {
569            llvm::SmallVectorImpl<char> diag_str(10);
570            info.FormatDiagnostic(diag_str);
571            diag_str.push_back('\0');
572            m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
573        }
574    }
575private:
576    LogSP m_log;
577};
578
579DiagnosticClient *
580ClangASTContext::getDiagnosticClient()
581{
582    if (m_diagnostic_client_ap.get() == NULL)
583        m_diagnostic_client_ap.reset(new NullDiagnosticClient);
584
585    return m_diagnostic_client_ap.get();
586}
587
588TargetOptions *
589ClangASTContext::getTargetOptions()
590{
591    if (m_target_options_ap.get() == NULL && !m_target_triple.empty())
592    {
593        m_target_options_ap.reset (new TargetOptions());
594        if (m_target_options_ap.get())
595            m_target_options_ap->Triple = m_target_triple;
596    }
597    return m_target_options_ap.get();
598}
599
600
601TargetInfo *
602ClangASTContext::getTargetInfo()
603{
604    // target_triple should be something like "x86_64-apple-darwin10"
605    if (m_target_info_ap.get() == NULL && !m_target_triple.empty())
606        m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnostic(), *getTargetOptions()));
607    return m_target_info_ap.get();
608}
609
610#pragma mark Basic Types
611
612static inline bool
613QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
614{
615    uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
616    if (qual_type_bit_size == bit_size)
617        return true;
618    return false;
619}
620
621clang_type_t
622ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
623{
624    ASTContext *ast = getASTContext();
625
626    assert (ast != NULL);
627
628    return GetBuiltinTypeForEncodingAndBitSize (ast, encoding, bit_size);
629}
630
631clang_type_t
632ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
633{
634    if (!ast)
635        return NULL;
636
637    switch (encoding)
638    {
639    case eEncodingInvalid:
640        if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
641            return ast->VoidPtrTy.getAsOpaquePtr();
642        break;
643
644    case eEncodingUint:
645        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
646            return ast->UnsignedCharTy.getAsOpaquePtr();
647        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
648            return ast->UnsignedShortTy.getAsOpaquePtr();
649        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
650            return ast->UnsignedIntTy.getAsOpaquePtr();
651        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
652            return ast->UnsignedLongTy.getAsOpaquePtr();
653        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
654            return ast->UnsignedLongLongTy.getAsOpaquePtr();
655        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
656            return ast->UnsignedInt128Ty.getAsOpaquePtr();
657        break;
658
659    case eEncodingSint:
660        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
661            return ast->CharTy.getAsOpaquePtr();
662        if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
663            return ast->ShortTy.getAsOpaquePtr();
664        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
665            return ast->IntTy.getAsOpaquePtr();
666        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
667            return ast->LongTy.getAsOpaquePtr();
668        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
669            return ast->LongLongTy.getAsOpaquePtr();
670        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
671            return ast->Int128Ty.getAsOpaquePtr();
672        break;
673
674    case eEncodingIEEE754:
675        if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
676            return ast->FloatTy.getAsOpaquePtr();
677        if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
678            return ast->DoubleTy.getAsOpaquePtr();
679        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
680            return ast->LongDoubleTy.getAsOpaquePtr();
681        break;
682
683    case eEncodingVector:
684    default:
685        break;
686    }
687
688    return NULL;
689}
690
691clang_type_t
692ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
693{
694    ASTContext *ast = getASTContext();
695
696    #define streq(a,b) strcmp(a,b) == 0
697    assert (ast != NULL);
698    if (ast)
699    {
700        switch (dw_ate)
701        {
702        default:
703            break;
704
705        case DW_ATE_address:
706            if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
707                return ast->VoidPtrTy.getAsOpaquePtr();
708            break;
709
710        case DW_ATE_boolean:
711            if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
712                return ast->BoolTy.getAsOpaquePtr();
713            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
714                return ast->UnsignedCharTy.getAsOpaquePtr();
715            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
716                return ast->UnsignedShortTy.getAsOpaquePtr();
717            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
718                return ast->UnsignedIntTy.getAsOpaquePtr();
719            break;
720
721        case DW_ATE_lo_user:
722            // This has been seen to mean DW_AT_complex_integer
723            if (::strstr(type_name, "complex"))
724            {
725                clang_type_t complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
726                return ast->getComplexType (QualType::getFromOpaquePtr(complex_int_clang_type)).getAsOpaquePtr();
727            }
728            break;
729
730        case DW_ATE_complex_float:
731            if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
732                return ast->FloatComplexTy.getAsOpaquePtr();
733            else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
734                return ast->DoubleComplexTy.getAsOpaquePtr();
735            else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
736                return ast->LongDoubleComplexTy.getAsOpaquePtr();
737            else
738            {
739                clang_type_t complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
740                return ast->getComplexType (QualType::getFromOpaquePtr(complex_float_clang_type)).getAsOpaquePtr();
741            }
742            break;
743
744        case DW_ATE_float:
745            if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
746                return ast->FloatTy.getAsOpaquePtr();
747            if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
748                return ast->DoubleTy.getAsOpaquePtr();
749            if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
750                return ast->LongDoubleTy.getAsOpaquePtr();
751            break;
752
753        case DW_ATE_signed:
754            if (type_name)
755            {
756                if (strstr(type_name, "long long"))
757                {
758                    if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
759                        return ast->LongLongTy.getAsOpaquePtr();
760                }
761                else if (strstr(type_name, "long"))
762                {
763                    if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
764                        return ast->LongTy.getAsOpaquePtr();
765                }
766                else if (strstr(type_name, "short"))
767                {
768                    if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
769                        return ast->ShortTy.getAsOpaquePtr();
770                }
771                else if (strstr(type_name, "char"))
772                {
773                    if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
774                        return ast->CharTy.getAsOpaquePtr();
775                    if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
776                        return ast->SignedCharTy.getAsOpaquePtr();
777                }
778                else if (strstr(type_name, "int"))
779                {
780                    if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
781                        return ast->IntTy.getAsOpaquePtr();
782                    if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
783                        return ast->Int128Ty.getAsOpaquePtr();
784                }
785                else if (streq(type_name, "wchar_t"))
786                {
787                    if (QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
788                        return ast->WCharTy.getAsOpaquePtr();
789                }
790                else if (streq(type_name, "void"))
791                {
792                    if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
793                        return ast->VoidTy.getAsOpaquePtr();
794                }
795            }
796            // We weren't able to match up a type name, just search by size
797            if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
798                return ast->CharTy.getAsOpaquePtr();
799            if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
800                return ast->ShortTy.getAsOpaquePtr();
801            if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
802                return ast->IntTy.getAsOpaquePtr();
803            if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
804                return ast->LongTy.getAsOpaquePtr();
805            if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
806                return ast->LongLongTy.getAsOpaquePtr();
807            if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
808                return ast->Int128Ty.getAsOpaquePtr();
809            break;
810
811        case DW_ATE_signed_char:
812            if (type_name)
813            {
814                if (streq(type_name, "signed char"))
815                {
816                    if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
817                        return ast->SignedCharTy.getAsOpaquePtr();
818                }
819            }
820            if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
821                return ast->CharTy.getAsOpaquePtr();
822            if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
823                return ast->SignedCharTy.getAsOpaquePtr();
824            break;
825
826        case DW_ATE_unsigned:
827            if (type_name)
828            {
829                if (strstr(type_name, "long long"))
830                {
831                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
832                        return ast->UnsignedLongLongTy.getAsOpaquePtr();
833                }
834                else if (strstr(type_name, "long"))
835                {
836                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
837                        return ast->UnsignedLongTy.getAsOpaquePtr();
838                }
839                else if (strstr(type_name, "short"))
840                {
841                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
842                        return ast->UnsignedShortTy.getAsOpaquePtr();
843                }
844                else if (strstr(type_name, "char"))
845                {
846                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
847                        return ast->UnsignedCharTy.getAsOpaquePtr();
848                }
849                else if (strstr(type_name, "int"))
850                {
851                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
852                        return ast->UnsignedIntTy.getAsOpaquePtr();
853                    if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
854                        return ast->UnsignedInt128Ty.getAsOpaquePtr();
855                }
856            }
857            // We weren't able to match up a type name, just search by size
858            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
859                return ast->UnsignedCharTy.getAsOpaquePtr();
860            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
861                return ast->UnsignedShortTy.getAsOpaquePtr();
862            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
863                return ast->UnsignedIntTy.getAsOpaquePtr();
864            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
865                return ast->UnsignedLongTy.getAsOpaquePtr();
866            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
867                return ast->UnsignedLongLongTy.getAsOpaquePtr();
868            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
869                return ast->UnsignedInt128Ty.getAsOpaquePtr();
870            break;
871
872        case DW_ATE_unsigned_char:
873            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
874                return ast->UnsignedCharTy.getAsOpaquePtr();
875            if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
876                return ast->UnsignedShortTy.getAsOpaquePtr();
877            break;
878
879        case DW_ATE_imaginary_float:
880            break;
881        }
882    }
883    // This assert should fire for anything that we don't catch above so we know
884    // to fix any issues we run into.
885    if (type_name)
886    {
887        fprintf (stderr, "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);
888    }
889    else
890    {
891        fprintf (stderr, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size);
892    }
893    return NULL;
894}
895
896clang_type_t
897ClangASTContext::GetBuiltInType_void(ASTContext *ast)
898{
899    return ast->VoidTy.getAsOpaquePtr();
900}
901
902clang_type_t
903ClangASTContext::GetBuiltInType_bool()
904{
905    return getASTContext()->BoolTy.getAsOpaquePtr();
906}
907
908clang_type_t
909ClangASTContext::GetBuiltInType_objc_id()
910{
911    return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinIdTy).getAsOpaquePtr();
912}
913
914clang_type_t
915ClangASTContext::GetBuiltInType_objc_Class()
916{
917    return getASTContext()->ObjCBuiltinClassTy.getAsOpaquePtr();
918}
919
920clang_type_t
921ClangASTContext::GetBuiltInType_objc_selector()
922{
923    return getASTContext()->getPointerType(getASTContext()->ObjCBuiltinSelTy).getAsOpaquePtr();
924}
925
926clang_type_t
927ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast)
928{
929    return ast->UnknownAnyTy.getAsOpaquePtr();
930}
931
932clang_type_t
933ClangASTContext::GetCStringType (bool is_const)
934{
935    QualType char_type(getASTContext()->CharTy);
936
937    if (is_const)
938        char_type.addConst();
939
940    return getASTContext()->getPointerType(char_type).getAsOpaquePtr();
941}
942
943clang_type_t
944ClangASTContext::GetVoidPtrType (bool is_const)
945{
946    return GetVoidPtrType(getASTContext(), is_const);
947}
948
949clang_type_t
950ClangASTContext::GetVoidPtrType (ASTContext *ast, bool is_const)
951{
952    QualType void_ptr_type(ast->VoidPtrTy);
953
954    if (is_const)
955        void_ptr_type.addConst();
956
957    return void_ptr_type.getAsOpaquePtr();
958}
959
960clang_type_t
961ClangASTContext::CopyType (ASTContext *dst_ast,
962                           ASTContext *src_ast,
963                           clang_type_t clang_type)
964{
965    FileSystemOptions file_system_options;
966    FileManager file_manager (file_system_options);
967    ASTImporter importer(*dst_ast, file_manager,
968                         *src_ast, file_manager,
969                         false);
970
971    QualType src (QualType::getFromOpaquePtr(clang_type));
972    QualType dst (importer.Import(src));
973
974    return dst.getAsOpaquePtr();
975}
976
977
978clang::Decl *
979ClangASTContext::CopyDecl (ASTContext *dst_ast,
980                           ASTContext *src_ast,
981                           clang::Decl *source_decl)
982{
983    FileSystemOptions file_system_options;
984    FileManager file_manager (file_system_options);
985    ASTImporter importer(*dst_ast, file_manager,
986                         *src_ast, file_manager,
987                         false);
988
989    return importer.Import(source_decl);
990}
991
992bool
993ClangASTContext::AreTypesSame(ASTContext *ast,
994             clang_type_t type1,
995             clang_type_t type2)
996{
997    return ast->hasSameType (QualType::getFromOpaquePtr(type1),
998                             QualType::getFromOpaquePtr(type2));
999}
1000
1001#pragma mark CVR modifiers
1002
1003clang_type_t
1004ClangASTContext::AddConstModifier (clang_type_t clang_type)
1005{
1006    if (clang_type)
1007    {
1008        QualType result(QualType::getFromOpaquePtr(clang_type));
1009        result.addConst();
1010        return result.getAsOpaquePtr();
1011    }
1012    return NULL;
1013}
1014
1015clang_type_t
1016ClangASTContext::AddRestrictModifier (clang_type_t clang_type)
1017{
1018    if (clang_type)
1019    {
1020        QualType result(QualType::getFromOpaquePtr(clang_type));
1021        result.getQualifiers().setRestrict (true);
1022        return result.getAsOpaquePtr();
1023    }
1024    return NULL;
1025}
1026
1027clang_type_t
1028ClangASTContext::AddVolatileModifier (clang_type_t clang_type)
1029{
1030    if (clang_type)
1031    {
1032        QualType result(QualType::getFromOpaquePtr(clang_type));
1033        result.getQualifiers().setVolatile (true);
1034        return result.getAsOpaquePtr();
1035    }
1036    return NULL;
1037}
1038
1039
1040clang_type_t
1041ClangASTContext::GetTypeForDecl (TagDecl *decl)
1042{
1043    // No need to call the getASTContext() accessor (which can create the AST
1044    // if it isn't created yet, because we can't have created a decl in this
1045    // AST if our AST didn't already exist...
1046    if (m_ast_ap.get())
1047        return m_ast_ap->getTagDeclType(decl).getAsOpaquePtr();
1048    return NULL;
1049}
1050
1051clang_type_t
1052ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
1053{
1054    // No need to call the getASTContext() accessor (which can create the AST
1055    // if it isn't created yet, because we can't have created a decl in this
1056    // AST if our AST didn't already exist...
1057    if (m_ast_ap.get())
1058        return m_ast_ap->getObjCInterfaceType(decl).getAsOpaquePtr();
1059    return NULL;
1060}
1061
1062#pragma mark Structure, Unions, Classes
1063
1064clang_type_t
1065ClangASTContext::CreateRecordType (const char *name, int kind, DeclContext *decl_ctx, LanguageType language)
1066{
1067    ASTContext *ast = getASTContext();
1068    assert (ast != NULL);
1069
1070    if (decl_ctx == NULL)
1071        decl_ctx = ast->getTranslationUnitDecl();
1072
1073
1074    if (language == eLanguageTypeObjC)
1075    {
1076        bool isForwardDecl = true;
1077        bool isInternal = false;
1078        return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal);
1079    }
1080
1081    // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1082    // we will need to update this code. I was told to currently always use
1083    // the CXXRecordDecl class since we often don't know from debug information
1084    // if something is struct or a class, so we default to always use the more
1085    // complete definition just in case.
1086    CXXRecordDecl *decl = CXXRecordDecl::Create(*ast,
1087                                                (TagDecl::TagKind)kind,
1088                                                decl_ctx,
1089                                                SourceLocation(),
1090                                                SourceLocation(),
1091                                                name && name[0] ? &ast->Idents.get(name) : NULL);
1092
1093    return ast->getTagDeclType(decl).getAsOpaquePtr();
1094}
1095
1096bool
1097ClangASTContext::SetHasExternalStorage (clang_type_t clang_type, bool has_extern)
1098{
1099    if (clang_type == NULL)
1100        return false;
1101
1102    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
1103
1104    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
1105    switch (type_class)
1106    {
1107    case clang::Type::Record:
1108        {
1109            CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
1110            if (cxx_record_decl)
1111            {
1112                cxx_record_decl->setHasExternalLexicalStorage (has_extern);
1113                cxx_record_decl->setHasExternalVisibleStorage (has_extern);
1114                return true;
1115            }
1116        }
1117        break;
1118
1119    case clang::Type::Enum:
1120        {
1121            EnumDecl *enum_decl = cast<EnumType>(qual_type)->getDecl();
1122            if (enum_decl)
1123            {
1124                enum_decl->setHasExternalLexicalStorage (has_extern);
1125                enum_decl->setHasExternalVisibleStorage (has_extern);
1126                return true;
1127            }
1128        }
1129        break;
1130
1131    case clang::Type::ObjCObject:
1132    case clang::Type::ObjCInterface:
1133        {
1134            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
1135            assert (objc_class_type);
1136            if (objc_class_type)
1137            {
1138                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1139
1140                if (class_interface_decl)
1141                {
1142                    class_interface_decl->setHasExternalLexicalStorage (has_extern);
1143                    class_interface_decl->setHasExternalVisibleStorage (has_extern);
1144                    return true;
1145                }
1146            }
1147        }
1148        break;
1149
1150    case clang::Type::Typedef:
1151        return ClangASTContext::SetHasExternalStorage (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), has_extern);
1152
1153    default:
1154        break;
1155    }
1156    return false;
1157}
1158
1159static bool
1160IsOperator (const char *name, OverloadedOperatorKind &op_kind)
1161{
1162    if (name == NULL || name[0] == '\0')
1163        return false;
1164
1165#define OPERATOR_PREFIX "operator"
1166#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
1167
1168    const char *post_op_name = NULL;
1169
1170    bool no_space = true;
1171
1172    if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
1173        return false;
1174
1175    post_op_name = name + OPERATOR_PREFIX_LENGTH;
1176
1177    if (post_op_name[0] == ' ')
1178    {
1179        post_op_name++;
1180        no_space = false;
1181    }
1182
1183#undef OPERATOR_PREFIX
1184#undef OPERATOR_PREFIX_LENGTH
1185
1186    // This is an operator, set the overloaded operator kind to invalid
1187    // in case this is a conversion operator...
1188    op_kind = NUM_OVERLOADED_OPERATORS;
1189
1190    switch (post_op_name[0])
1191    {
1192    default:
1193        if (no_space)
1194            return false;
1195        break;
1196    case 'n':
1197        if (no_space)
1198            return false;
1199        if  (strcmp (post_op_name, "new") == 0)
1200            op_kind = OO_New;
1201        else if (strcmp (post_op_name, "new[]") == 0)
1202            op_kind = OO_Array_New;
1203        break;
1204
1205    case 'd':
1206        if (no_space)
1207            return false;
1208        if (strcmp (post_op_name, "delete") == 0)
1209            op_kind = OO_Delete;
1210        else if (strcmp (post_op_name, "delete[]") == 0)
1211            op_kind = OO_Array_Delete;
1212        break;
1213
1214    case '+':
1215        if (post_op_name[1] == '\0')
1216            op_kind = OO_Plus;
1217        else if (post_op_name[2] == '\0')
1218        {
1219            if (post_op_name[1] == '=')
1220                op_kind = OO_PlusEqual;
1221            else if (post_op_name[1] == '+')
1222                op_kind = OO_PlusPlus;
1223        }
1224        break;
1225
1226    case '-':
1227        if (post_op_name[1] == '\0')
1228            op_kind = OO_Minus;
1229        else if (post_op_name[2] == '\0')
1230        {
1231            switch (post_op_name[1])
1232            {
1233            case '=': op_kind = OO_MinusEqual; break;
1234            case '-': op_kind = OO_MinusMinus; break;
1235            case '>': op_kind = OO_Arrow; break;
1236            }
1237        }
1238        else if (post_op_name[3] == '\0')
1239        {
1240            if (post_op_name[2] == '*')
1241                op_kind = OO_ArrowStar; break;
1242        }
1243        break;
1244
1245    case '*':
1246        if (post_op_name[1] == '\0')
1247            op_kind = OO_Star;
1248        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1249            op_kind = OO_StarEqual;
1250        break;
1251
1252    case '/':
1253        if (post_op_name[1] == '\0')
1254            op_kind = OO_Slash;
1255        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1256            op_kind = OO_SlashEqual;
1257        break;
1258
1259    case '%':
1260        if (post_op_name[1] == '\0')
1261            op_kind = OO_Percent;
1262        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1263            op_kind = OO_PercentEqual;
1264        break;
1265
1266
1267    case '^':
1268        if (post_op_name[1] == '\0')
1269            op_kind = OO_Caret;
1270        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1271            op_kind = OO_CaretEqual;
1272        break;
1273
1274    case '&':
1275        if (post_op_name[1] == '\0')
1276            op_kind = OO_Amp;
1277        else if (post_op_name[2] == '\0')
1278        {
1279            switch (post_op_name[1])
1280            {
1281            case '=': op_kind = OO_AmpEqual; break;
1282            case '&': op_kind = OO_AmpAmp; break;
1283            }
1284        }
1285        break;
1286
1287    case '|':
1288        if (post_op_name[1] == '\0')
1289            op_kind = OO_Pipe;
1290        else if (post_op_name[2] == '\0')
1291        {
1292            switch (post_op_name[1])
1293            {
1294            case '=': op_kind = OO_PipeEqual; break;
1295            case '|': op_kind = OO_PipePipe; break;
1296            }
1297        }
1298        break;
1299
1300    case '~':
1301        if (post_op_name[1] == '\0')
1302            op_kind = OO_Tilde;
1303        break;
1304
1305    case '!':
1306        if (post_op_name[1] == '\0')
1307            op_kind = OO_Exclaim;
1308        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1309            op_kind = OO_ExclaimEqual;
1310        break;
1311
1312    case '=':
1313        if (post_op_name[1] == '\0')
1314            op_kind = OO_Equal;
1315        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1316            op_kind = OO_EqualEqual;
1317        break;
1318
1319    case '<':
1320        if (post_op_name[1] == '\0')
1321            op_kind = OO_Less;
1322        else if (post_op_name[2] == '\0')
1323        {
1324            switch (post_op_name[1])
1325            {
1326            case '<': op_kind = OO_LessLess; break;
1327            case '=': op_kind = OO_LessEqual; break;
1328            }
1329        }
1330        else if (post_op_name[3] == '\0')
1331        {
1332            if (post_op_name[2] == '=')
1333                op_kind = OO_LessLessEqual;
1334        }
1335        break;
1336
1337    case '>':
1338        if (post_op_name[1] == '\0')
1339            op_kind = OO_Greater;
1340        else if (post_op_name[2] == '\0')
1341        {
1342            switch (post_op_name[1])
1343            {
1344            case '>': op_kind = OO_GreaterGreater; break;
1345            case '=': op_kind = OO_GreaterEqual; break;
1346            }
1347        }
1348        else if (post_op_name[1] == '>' &&
1349                 post_op_name[2] == '=' &&
1350                 post_op_name[3] == '\0')
1351        {
1352                op_kind = OO_GreaterGreaterEqual;
1353        }
1354        break;
1355
1356    case ',':
1357        if (post_op_name[1] == '\0')
1358            op_kind = OO_Comma;
1359        break;
1360
1361    case '(':
1362        if (post_op_name[1] == ')' && post_op_name[2] == '\0')
1363            op_kind = OO_Call;
1364        break;
1365
1366    case '[':
1367        if (post_op_name[1] == ']' && post_op_name[2] == '\0')
1368            op_kind = OO_Subscript;
1369        break;
1370    }
1371
1372    return true;
1373}
1374
1375static inline bool
1376check_op_param (bool unary, bool binary, uint32_t num_params)
1377{
1378    // The parameter count doens't include "this"
1379    if (num_params == 0)
1380        return unary;
1381    if (num_params == 1)
1382        return binary;
1383    return false;
1384}
1385
1386bool
1387ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params)
1388{
1389#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (Unary, Binary, num_params);
1390    switch (op_kind)
1391    {
1392#include "clang/Basic/OperatorKinds.def"
1393        default: break;
1394    }
1395    return false;
1396}
1397
1398CXXMethodDecl *
1399ClangASTContext::AddMethodToCXXRecordType
1400(
1401    ASTContext *ast,
1402    clang_type_t record_opaque_type,
1403    const char *name,
1404    clang_type_t method_opaque_type,
1405    lldb::AccessType access,
1406    bool is_virtual,
1407    bool is_static,
1408    bool is_inline,
1409    bool is_explicit
1410)
1411{
1412    if (!record_opaque_type || !method_opaque_type || !name)
1413        return NULL;
1414
1415    assert(ast);
1416
1417    IdentifierTable *identifier_table = &ast->Idents;
1418
1419    assert(identifier_table);
1420
1421    QualType record_qual_type(QualType::getFromOpaquePtr(record_opaque_type));
1422
1423    CXXRecordDecl *cxx_record_decl = record_qual_type->getAsCXXRecordDecl();
1424
1425    if (cxx_record_decl == NULL)
1426        return NULL;
1427
1428    QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
1429
1430    CXXMethodDecl *cxx_method_decl = NULL;
1431
1432    DeclarationName decl_name (&identifier_table->get(name));
1433
1434    const bool is_implicitly_declared = false;
1435
1436    const clang::FunctionType *function_Type = dyn_cast<FunctionType>(method_qual_type.getTypePtr());
1437
1438    if (function_Type == NULL)
1439        return NULL;
1440
1441    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(function_Type));
1442
1443    if (!method_function_prototype)
1444        return NULL;
1445
1446    unsigned int num_params = method_function_prototype->getNumArgs();
1447
1448    if (name[0] == '~')
1449    {
1450        cxx_method_decl = CXXDestructorDecl::Create (*ast,
1451                                                     cxx_record_decl,
1452                                                     SourceLocation(),
1453                                                     DeclarationNameInfo (ast->DeclarationNames.getCXXDestructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
1454                                                     method_qual_type,
1455                                                     NULL,
1456                                                     is_inline,
1457                                                     is_implicitly_declared);
1458    }
1459    else if (decl_name == cxx_record_decl->getDeclName())
1460    {
1461        cxx_method_decl = CXXConstructorDecl::Create (*ast,
1462                                                      cxx_record_decl,
1463                                                      SourceLocation(),
1464                                                      DeclarationNameInfo (ast->DeclarationNames.getCXXConstructorName (ast->getCanonicalType (record_qual_type)), SourceLocation()),
1465                                                      method_qual_type,
1466                                                      NULL, // TypeSourceInfo *
1467                                                      is_explicit,
1468                                                      is_inline,
1469                                                      is_implicitly_declared);
1470    }
1471    else
1472    {
1473
1474        OverloadedOperatorKind op_kind = NUM_OVERLOADED_OPERATORS;
1475        if (IsOperator (name, op_kind))
1476        {
1477            if (op_kind != NUM_OVERLOADED_OPERATORS)
1478            {
1479                // Check the number of operator parameters. Sometimes we have
1480                // seen bad DWARF that doesn't correctly describe operators and
1481                // if we try to create a methed and add it to the class, clang
1482                // will assert and crash, so we need to make sure things are
1483                // acceptable.
1484                if (!ClangASTContext::CheckOverloadedOperatorKindParameterCount (op_kind, num_params))
1485                    return NULL;
1486                cxx_method_decl = CXXMethodDecl::Create (*ast,
1487                                                         cxx_record_decl,
1488                                                         SourceLocation(),
1489                                                         DeclarationNameInfo (ast->DeclarationNames.getCXXOperatorName (op_kind), SourceLocation()),
1490                                                         method_qual_type,
1491                                                         NULL, // TypeSourceInfo *
1492                                                         is_static,
1493                                                         SC_None,
1494                                                         is_inline,
1495                                                         SourceLocation());
1496            }
1497            else if (num_params == 0)
1498            {
1499                // Conversion operators don't take params...
1500                cxx_method_decl = CXXConversionDecl::Create (*ast,
1501                                                             cxx_record_decl,
1502                                                             SourceLocation(),
1503                                                             DeclarationNameInfo (ast->DeclarationNames.getCXXConversionFunctionName (ast->getCanonicalType (function_Type->getResultType())), SourceLocation()),
1504                                                             method_qual_type,
1505                                                             NULL, // TypeSourceInfo *
1506                                                             is_inline,
1507                                                             is_explicit,
1508                                                             SourceLocation());
1509            }
1510        }
1511
1512        if (cxx_method_decl == NULL)
1513        {
1514            cxx_method_decl = CXXMethodDecl::Create (*ast,
1515                                                     cxx_record_decl,
1516                                                     SourceLocation(),
1517                                                     DeclarationNameInfo (decl_name, SourceLocation()),
1518                                                     method_qual_type,
1519                                                     NULL, // TypeSourceInfo *
1520                                                     is_static,
1521                                                     SC_None,
1522                                                     is_inline,
1523                                                     SourceLocation());
1524        }
1525    }
1526
1527    AccessSpecifier access_specifier = ConvertAccessTypeToAccessSpecifier (access);
1528
1529    cxx_method_decl->setAccess (access_specifier);
1530    cxx_method_decl->setVirtualAsWritten (is_virtual);
1531
1532    // Populate the method decl with parameter decls
1533
1534    llvm::SmallVector<ParmVarDecl *, 12> params;
1535
1536    for (int param_index = 0;
1537         param_index < num_params;
1538         ++param_index)
1539    {
1540        params.push_back (ParmVarDecl::Create (*ast,
1541                                               cxx_method_decl,
1542                                               SourceLocation(),
1543                                               SourceLocation(),
1544                                               NULL, // anonymous
1545                                               method_function_prototype->getArgType(param_index),
1546                                               NULL,
1547                                               SC_None,
1548                                               SC_None,
1549                                               NULL));
1550    }
1551
1552    cxx_method_decl->setParams (params.data(), num_params);
1553
1554    cxx_record_decl->addDecl (cxx_method_decl);
1555
1556//    printf ("decl->isPolymorphic()             = %i\n", cxx_record_decl->isPolymorphic());
1557//    printf ("decl->isAggregate()               = %i\n", cxx_record_decl->isAggregate());
1558//    printf ("decl->isPOD()                     = %i\n", cxx_record_decl->isPOD());
1559//    printf ("decl->isEmpty()                   = %i\n", cxx_record_decl->isEmpty());
1560//    printf ("decl->isAbstract()                = %i\n", cxx_record_decl->isAbstract());
1561//    printf ("decl->hasTrivialConstructor()     = %i\n", cxx_record_decl->hasTrivialConstructor());
1562//    printf ("decl->hasTrivialCopyConstructor() = %i\n", cxx_record_decl->hasTrivialCopyConstructor());
1563//    printf ("decl->hasTrivialCopyAssignment()  = %i\n", cxx_record_decl->hasTrivialCopyAssignment());
1564//    printf ("decl->hasTrivialDestructor()      = %i\n", cxx_record_decl->hasTrivialDestructor());
1565    return cxx_method_decl;
1566}
1567
1568bool
1569ClangASTContext::AddFieldToRecordType
1570(
1571    ASTContext *ast,
1572    clang_type_t record_clang_type,
1573    const char *name,
1574    clang_type_t field_type,
1575    AccessType access,
1576    uint32_t bitfield_bit_size
1577)
1578{
1579    if (record_clang_type == NULL || field_type == NULL)
1580        return false;
1581
1582    IdentifierTable *identifier_table = &ast->Idents;
1583
1584    assert (ast != NULL);
1585    assert (identifier_table != NULL);
1586
1587    QualType record_qual_type(QualType::getFromOpaquePtr(record_clang_type));
1588
1589    const clang::Type *clang_type = record_qual_type.getTypePtr();
1590    if (clang_type)
1591    {
1592        const RecordType *record_type = dyn_cast<RecordType>(clang_type);
1593
1594        if (record_type)
1595        {
1596            RecordDecl *record_decl = record_type->getDecl();
1597
1598            clang::Expr *bit_width = NULL;
1599            if (bitfield_bit_size != 0)
1600            {
1601                APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
1602                bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
1603            }
1604            FieldDecl *field = FieldDecl::Create (*ast,
1605                                                  record_decl,
1606                                                  SourceLocation(),
1607                                                  SourceLocation(),
1608                                                  name ? &identifier_table->get(name) : NULL, // Identifier
1609                                                  QualType::getFromOpaquePtr(field_type), // Field type
1610                                                  NULL,       // TInfo *
1611                                                  bit_width,  // BitWidth
1612                                                  false,      // Mutable
1613                                                  false);     // HasInit
1614
1615            field->setAccess (ConvertAccessTypeToAccessSpecifier (access));
1616
1617            if (field)
1618            {
1619                record_decl->addDecl(field);
1620            }
1621        }
1622        else
1623        {
1624            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(clang_type);
1625            if (objc_class_type)
1626            {
1627                bool is_synthesized = false;
1628                ClangASTContext::AddObjCClassIVar (ast,
1629                                                   record_clang_type,
1630                                                   name,
1631                                                   field_type,
1632                                                   access,
1633                                                   bitfield_bit_size,
1634                                                   is_synthesized);
1635            }
1636        }
1637    }
1638    return false;
1639}
1640
1641bool
1642ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1643{
1644    return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1645}
1646
1647bool
1648ClangASTContext::FieldIsBitfield
1649(
1650    ASTContext *ast,
1651    FieldDecl* field,
1652    uint32_t& bitfield_bit_size
1653)
1654{
1655    if (ast == NULL || field == NULL)
1656        return false;
1657
1658    if (field->isBitField())
1659    {
1660        Expr* bit_width_expr = field->getBitWidth();
1661        if (bit_width_expr)
1662        {
1663            llvm::APSInt bit_width_apsint;
1664            if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
1665            {
1666                bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1667                return true;
1668            }
1669        }
1670    }
1671    return false;
1672}
1673
1674bool
1675ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1676{
1677    if (record_decl == NULL)
1678        return false;
1679
1680    if (!record_decl->field_empty())
1681        return true;
1682
1683    // No fields, lets check this is a CXX record and check the base classes
1684    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1685    if (cxx_record_decl)
1686    {
1687        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1688        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1689             base_class != base_class_end;
1690             ++base_class)
1691        {
1692            const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1693            if (RecordHasFields(base_class_decl))
1694                return true;
1695        }
1696    }
1697    return false;
1698}
1699
1700void
1701ClangASTContext::SetDefaultAccessForRecordFields (clang_type_t clang_type, int default_accessibility, int *assigned_accessibilities, size_t num_assigned_accessibilities)
1702{
1703    if (clang_type)
1704    {
1705        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
1706
1707        const RecordType *record_type = dyn_cast<RecordType>(qual_type.getTypePtr());
1708        if (record_type)
1709        {
1710            RecordDecl *record_decl = record_type->getDecl();
1711            if (record_decl)
1712            {
1713                uint32_t field_idx;
1714                RecordDecl::field_iterator field, field_end;
1715                for (field = record_decl->field_begin(), field_end = record_decl->field_end(), field_idx = 0;
1716                     field != field_end;
1717                     ++field, ++field_idx)
1718                {
1719                    // If no accessibility was assigned, assign the correct one
1720                    if (field_idx < num_assigned_accessibilities && assigned_accessibilities[field_idx] == clang::AS_none)
1721                        field->setAccess ((AccessSpecifier)default_accessibility);
1722                }
1723            }
1724        }
1725    }
1726}
1727
1728#pragma mark C++ Base Classes
1729
1730CXXBaseSpecifier *
1731ClangASTContext::CreateBaseClassSpecifier (clang_type_t base_class_type, AccessType access, bool is_virtual, bool base_of_class)
1732{
1733    if (base_class_type)
1734        return new CXXBaseSpecifier (SourceRange(),
1735                                     is_virtual,
1736                                     base_of_class,
1737                                     ConvertAccessTypeToAccessSpecifier (access),
1738                                     getASTContext()->CreateTypeSourceInfo (QualType::getFromOpaquePtr(base_class_type)),
1739                                     SourceLocation());
1740    return NULL;
1741}
1742
1743void
1744ClangASTContext::DeleteBaseClassSpecifiers (CXXBaseSpecifier **base_classes, unsigned num_base_classes)
1745{
1746    for (unsigned i=0; i<num_base_classes; ++i)
1747    {
1748        delete base_classes[i];
1749        base_classes[i] = NULL;
1750    }
1751}
1752
1753bool
1754ClangASTContext::SetBaseClassesForClassType (clang_type_t class_clang_type, CXXBaseSpecifier const * const *base_classes, unsigned num_base_classes)
1755{
1756    if (class_clang_type)
1757    {
1758        CXXRecordDecl *cxx_record_decl = QualType::getFromOpaquePtr(class_clang_type)->getAsCXXRecordDecl();
1759        if (cxx_record_decl)
1760        {
1761            cxx_record_decl->setBases(base_classes, num_base_classes);
1762            return true;
1763        }
1764    }
1765    return false;
1766}
1767#pragma mark Objective C Classes
1768
1769clang_type_t
1770ClangASTContext::CreateObjCClass
1771(
1772    const char *name,
1773    DeclContext *decl_ctx,
1774    bool isForwardDecl,
1775    bool isInternal
1776)
1777{
1778    ASTContext *ast = getASTContext();
1779    assert (ast != NULL);
1780    assert (name && name[0]);
1781    if (decl_ctx == NULL)
1782        decl_ctx = ast->getTranslationUnitDecl();
1783
1784    // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1785    // we will need to update this code. I was told to currently always use
1786    // the CXXRecordDecl class since we often don't know from debug information
1787    // if something is struct or a class, so we default to always use the more
1788    // complete definition just in case.
1789    ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
1790                                                         decl_ctx,
1791                                                         SourceLocation(),
1792                                                         &ast->Idents.get(name),
1793                                                         SourceLocation(),
1794                                                         isForwardDecl,
1795                                                         isInternal);
1796
1797    return ast->getObjCInterfaceType(decl).getAsOpaquePtr();
1798}
1799
1800bool
1801ClangASTContext::SetObjCSuperClass (clang_type_t class_opaque_type, clang_type_t super_opaque_type)
1802{
1803    if (class_opaque_type && super_opaque_type)
1804    {
1805        QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1806        QualType super_qual_type(QualType::getFromOpaquePtr(super_opaque_type));
1807        const clang::Type *class_type = class_qual_type.getTypePtr();
1808        const clang::Type *super_type = super_qual_type.getTypePtr();
1809        if (class_type && super_type)
1810        {
1811            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1812            const ObjCObjectType *objc_super_type = dyn_cast<ObjCObjectType>(super_type);
1813            if (objc_class_type && objc_super_type)
1814            {
1815                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1816                ObjCInterfaceDecl *super_interface_decl = objc_super_type->getInterface();
1817                if (class_interface_decl && super_interface_decl)
1818                {
1819                    class_interface_decl->setSuperClass(super_interface_decl);
1820                    return true;
1821                }
1822            }
1823        }
1824    }
1825    return false;
1826}
1827
1828
1829bool
1830ClangASTContext::AddObjCClassIVar
1831(
1832    ASTContext *ast,
1833    clang_type_t class_opaque_type,
1834    const char *name,
1835    clang_type_t ivar_opaque_type,
1836    AccessType access,
1837    uint32_t bitfield_bit_size,
1838    bool is_synthesized
1839)
1840{
1841    if (class_opaque_type == NULL || ivar_opaque_type == NULL)
1842        return false;
1843
1844    IdentifierTable *identifier_table = &ast->Idents;
1845
1846    assert (ast != NULL);
1847    assert (identifier_table != NULL);
1848
1849    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1850
1851    const clang::Type *class_type = class_qual_type.getTypePtr();
1852    if (class_type)
1853    {
1854        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1855
1856        if (objc_class_type)
1857        {
1858            ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1859
1860            if (class_interface_decl)
1861            {
1862                clang::Expr *bit_width = NULL;
1863                if (bitfield_bit_size != 0)
1864                {
1865                    APInt bitfield_bit_size_apint(ast->getTypeSize(ast->IntTy), bitfield_bit_size);
1866                    bit_width = new (*ast)IntegerLiteral (*ast, bitfield_bit_size_apint, ast->IntTy, SourceLocation());
1867                }
1868
1869                ObjCIvarDecl *field = ObjCIvarDecl::Create (*ast,
1870                                                            class_interface_decl,
1871                                                            SourceLocation(),
1872                                                            SourceLocation(),
1873                                                            &identifier_table->get(name), // Identifier
1874                                                            QualType::getFromOpaquePtr(ivar_opaque_type), // Field type
1875                                                            NULL, // TypeSourceInfo *
1876                                                            ConvertAccessTypeToObjCIvarAccessControl (access),
1877                                                            bit_width,
1878                                                            is_synthesized);
1879
1880                if (field)
1881                {
1882                    class_interface_decl->addDecl(field);
1883                    return true;
1884                }
1885            }
1886        }
1887    }
1888    return false;
1889}
1890
1891
1892bool
1893ClangASTContext::ObjCTypeHasIVars (clang_type_t class_opaque_type, bool check_superclass)
1894{
1895    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1896
1897    const clang::Type *class_type = class_qual_type.getTypePtr();
1898    if (class_type)
1899    {
1900        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1901
1902        if (objc_class_type)
1903            return ObjCDeclHasIVars (objc_class_type->getInterface(), check_superclass);
1904    }
1905    return false;
1906}
1907
1908bool
1909ClangASTContext::ObjCDeclHasIVars (ObjCInterfaceDecl *class_interface_decl, bool check_superclass)
1910{
1911    while (class_interface_decl)
1912    {
1913        if (class_interface_decl->ivar_size() > 0)
1914            return true;
1915
1916        if (check_superclass)
1917            class_interface_decl = class_interface_decl->getSuperClass();
1918        else
1919            break;
1920    }
1921    return false;
1922}
1923
1924ObjCMethodDecl *
1925ClangASTContext::AddMethodToObjCObjectType
1926(
1927    ASTContext *ast,
1928    clang_type_t class_opaque_type,
1929    const char *name,  // the full symbol name as seen in the symbol table ("-[NString stringWithCString:]")
1930    clang_type_t method_opaque_type,
1931    lldb::AccessType access
1932)
1933{
1934    if (class_opaque_type == NULL || method_opaque_type == NULL)
1935        return NULL;
1936
1937    IdentifierTable *identifier_table = &ast->Idents;
1938
1939    assert (ast != NULL);
1940    assert (identifier_table != NULL);
1941
1942    QualType class_qual_type(QualType::getFromOpaquePtr(class_opaque_type));
1943
1944    const clang::Type *class_type = class_qual_type.getTypePtr();
1945    if (class_type == NULL)
1946        return NULL;
1947
1948    const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(class_type);
1949
1950    if (objc_class_type == NULL)
1951        return NULL;
1952
1953    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
1954
1955    if (class_interface_decl == NULL)
1956        return NULL;
1957
1958    const char *selector_start = ::strchr (name, ' ');
1959    if (selector_start == NULL)
1960        return NULL;
1961
1962    selector_start++;
1963    if (!(::isalpha (selector_start[0]) || selector_start[0] == '_'))
1964        return NULL;
1965    llvm::SmallVector<IdentifierInfo *, 12> selector_idents;
1966
1967    size_t len = 0;
1968    const char *start;
1969    //printf ("name = '%s'\n", name);
1970
1971    unsigned num_selectors_with_args = 0;
1972    for (start = selector_start;
1973         start && *start != '\0' && *start != ']';
1974         start += len)
1975    {
1976        len = ::strcspn(start, ":]");
1977        bool has_arg = (start[len] == ':');
1978        if (has_arg)
1979            ++num_selectors_with_args;
1980        selector_idents.push_back (&identifier_table->get (StringRef (start, len)));
1981        if (has_arg)
1982            len += 1;
1983    }
1984
1985
1986    if (selector_idents.size() == 0)
1987        return 0;
1988
1989    clang::Selector method_selector = ast->Selectors.getSelector (num_selectors_with_args ? selector_idents.size() : 0,
1990                                                                          selector_idents.data());
1991
1992    QualType method_qual_type (QualType::getFromOpaquePtr (method_opaque_type));
1993
1994    // Populate the method decl with parameter decls
1995    const clang::Type *method_type(method_qual_type.getTypePtr());
1996
1997    if (method_type == NULL)
1998        return NULL;
1999
2000    const FunctionProtoType *method_function_prototype (dyn_cast<FunctionProtoType>(method_type));
2001
2002    if (!method_function_prototype)
2003        return NULL;
2004
2005
2006    bool is_variadic = false;
2007    bool is_synthesized = false;
2008    bool is_defined = false;
2009    ObjCMethodDecl::ImplementationControl imp_control = ObjCMethodDecl::None;
2010
2011    const unsigned num_args = method_function_prototype->getNumArgs();
2012
2013    ObjCMethodDecl *objc_method_decl = ObjCMethodDecl::Create (*ast,
2014                                                               SourceLocation(), // beginLoc,
2015                                                               SourceLocation(), // endLoc,
2016                                                               method_selector,
2017                                                               method_function_prototype->getResultType(),
2018                                                               NULL, // TypeSourceInfo *ResultTInfo,
2019                                                               GetDeclContextForType (class_opaque_type),
2020                                                               name[0] == '-',
2021                                                               is_variadic,
2022                                                               is_synthesized,
2023                                                               is_defined,
2024                                                               imp_control,
2025                                                               num_args);
2026
2027
2028    if (objc_method_decl == NULL)
2029        return NULL;
2030
2031    if (num_args > 0)
2032    {
2033        llvm::SmallVector<ParmVarDecl *, 12> params;
2034
2035        for (int param_index = 0; param_index < num_args; ++param_index)
2036        {
2037            params.push_back (ParmVarDecl::Create (*ast,
2038                                                   objc_method_decl,
2039                                                   SourceLocation(),
2040                                                   SourceLocation(),
2041                                                   NULL, // anonymous
2042                                                   method_function_prototype->getArgType(param_index),
2043                                                   NULL,
2044                                                   SC_Auto,
2045                                                   SC_Auto,
2046                                                   NULL));
2047        }
2048
2049        objc_method_decl->setMethodParams(*ast, params.data(), params.size(), num_args);
2050    }
2051
2052    class_interface_decl->addDecl (objc_method_decl);
2053
2054
2055    return objc_method_decl;
2056}
2057
2058
2059uint32_t
2060ClangASTContext::GetTypeInfo
2061(
2062    clang_type_t clang_type,
2063    clang::ASTContext *ast,
2064    clang_type_t *pointee_or_element_clang_type
2065)
2066{
2067    if (clang_type == NULL)
2068        return 0;
2069
2070    if (pointee_or_element_clang_type)
2071        *pointee_or_element_clang_type = NULL;
2072
2073    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2074
2075    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2076    switch (type_class)
2077    {
2078    case clang::Type::Builtin:
2079        switch (cast<clang::BuiltinType>(qual_type)->getKind())
2080        {
2081        case clang::BuiltinType::ObjCId:
2082        case clang::BuiltinType::ObjCClass:
2083            if (ast && pointee_or_element_clang_type)
2084                *pointee_or_element_clang_type = ast->ObjCBuiltinClassTy.getAsOpaquePtr();
2085            return eTypeIsBuiltIn | eTypeIsPointer | eTypeHasValue;
2086                break;
2087        case clang::BuiltinType::Bool:
2088        case clang::BuiltinType::Char_U:
2089        case clang::BuiltinType::UChar:
2090        case clang::BuiltinType::WChar_U:
2091        case clang::BuiltinType::Char16:
2092        case clang::BuiltinType::Char32:
2093        case clang::BuiltinType::UShort:
2094        case clang::BuiltinType::UInt:
2095        case clang::BuiltinType::ULong:
2096        case clang::BuiltinType::ULongLong:
2097        case clang::BuiltinType::UInt128:
2098        case clang::BuiltinType::Char_S:
2099        case clang::BuiltinType::SChar:
2100        case clang::BuiltinType::WChar_S:
2101        case clang::BuiltinType::Short:
2102        case clang::BuiltinType::Int:
2103        case clang::BuiltinType::Long:
2104        case clang::BuiltinType::LongLong:
2105        case clang::BuiltinType::Int128:
2106        case clang::BuiltinType::Float:
2107        case clang::BuiltinType::Double:
2108        case clang::BuiltinType::LongDouble:
2109                return eTypeIsBuiltIn | eTypeHasValue | eTypeIsScalar;
2110        default:
2111            break;
2112        }
2113        return eTypeIsBuiltIn | eTypeHasValue;
2114
2115    case clang::Type::BlockPointer:
2116        if (pointee_or_element_clang_type)
2117            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2118        return eTypeIsPointer | eTypeHasChildren | eTypeIsBlock;
2119
2120    case clang::Type::Complex:                          return eTypeIsBuiltIn | eTypeHasValue;
2121
2122    case clang::Type::ConstantArray:
2123    case clang::Type::DependentSizedArray:
2124    case clang::Type::IncompleteArray:
2125    case clang::Type::VariableArray:
2126        if (pointee_or_element_clang_type)
2127            *pointee_or_element_clang_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
2128        return eTypeHasChildren | eTypeIsArray;
2129
2130    case clang::Type::DependentName:                    return 0;
2131    case clang::Type::DependentSizedExtVector:          return eTypeHasChildren | eTypeIsVector;
2132    case clang::Type::DependentTemplateSpecialization:  return eTypeIsTemplate;
2133    case clang::Type::Decltype:                         return 0;
2134
2135    case clang::Type::Enum:
2136        if (pointee_or_element_clang_type)
2137            *pointee_or_element_clang_type = cast<EnumType>(qual_type)->getDecl()->getIntegerType().getAsOpaquePtr();
2138        return eTypeIsEnumeration | eTypeHasValue;
2139
2140    case clang::Type::Elaborated:                       return 0;
2141    case clang::Type::ExtVector:                        return eTypeHasChildren | eTypeIsVector;
2142    case clang::Type::FunctionProto:                    return eTypeIsFuncPrototype | eTypeHasValue;
2143    case clang::Type::FunctionNoProto:                  return eTypeIsFuncPrototype | eTypeHasValue;
2144    case clang::Type::InjectedClassName:                return 0;
2145
2146    case clang::Type::LValueReference:
2147    case clang::Type::RValueReference:
2148        if (pointee_or_element_clang_type)
2149            *pointee_or_element_clang_type = cast<ReferenceType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr();
2150        return eTypeHasChildren | eTypeIsReference | eTypeHasValue;
2151
2152    case clang::Type::MemberPointer:                    return eTypeIsPointer   | eTypeIsMember | eTypeHasValue;
2153
2154    case clang::Type::ObjCObjectPointer:
2155        if (pointee_or_element_clang_type)
2156            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2157        return eTypeHasChildren | eTypeIsObjC | eTypeIsClass | eTypeIsPointer | eTypeHasValue;
2158
2159    case clang::Type::ObjCObject:                       return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
2160    case clang::Type::ObjCInterface:                    return eTypeHasChildren | eTypeIsObjC | eTypeIsClass;
2161
2162    case clang::Type::Pointer:
2163        if (pointee_or_element_clang_type)
2164            *pointee_or_element_clang_type = qual_type->getPointeeType().getAsOpaquePtr();
2165        return eTypeHasChildren | eTypeIsPointer | eTypeHasValue;
2166
2167    case clang::Type::Record:
2168        if (qual_type->getAsCXXRecordDecl())
2169            return eTypeHasChildren | eTypeIsClass | eTypeIsCPlusPlus;
2170        else
2171            return eTypeHasChildren | eTypeIsStructUnion;
2172        break;
2173    case clang::Type::SubstTemplateTypeParm:            return eTypeIsTemplate;
2174    case clang::Type::TemplateTypeParm:                 return eTypeIsTemplate;
2175    case clang::Type::TemplateSpecialization:           return eTypeIsTemplate;
2176
2177    case clang::Type::Typedef:
2178        return eTypeIsTypedef | ClangASTContext::GetTypeInfo (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2179                                                                  ast,
2180                                                                  pointee_or_element_clang_type);
2181
2182    case clang::Type::TypeOfExpr:                       return 0;
2183    case clang::Type::TypeOf:                           return 0;
2184    case clang::Type::UnresolvedUsing:                  return 0;
2185    case clang::Type::Vector:                           return eTypeHasChildren | eTypeIsVector;
2186    default:                                            return 0;
2187    }
2188    return 0;
2189}
2190
2191
2192#pragma mark Aggregate Types
2193
2194bool
2195ClangASTContext::IsAggregateType (clang_type_t clang_type)
2196{
2197    if (clang_type == NULL)
2198        return false;
2199
2200    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
2201
2202    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2203    switch (type_class)
2204    {
2205    case clang::Type::IncompleteArray:
2206    case clang::Type::VariableArray:
2207    case clang::Type::ConstantArray:
2208    case clang::Type::ExtVector:
2209    case clang::Type::Vector:
2210    case clang::Type::Record:
2211    case clang::Type::ObjCObject:
2212    case clang::Type::ObjCInterface:
2213        return true;
2214
2215    case clang::Type::Typedef:
2216        return ClangASTContext::IsAggregateType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2217
2218    default:
2219        break;
2220    }
2221    // The clang type does have a value
2222    return false;
2223}
2224
2225uint32_t
2226ClangASTContext::GetNumChildren (clang::ASTContext *ast, clang_type_t clang_type, bool omit_empty_base_classes)
2227{
2228    if (clang_type == NULL)
2229        return 0;
2230
2231    uint32_t num_children = 0;
2232    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
2233    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2234    switch (type_class)
2235    {
2236    case clang::Type::Builtin:
2237        switch (cast<clang::BuiltinType>(qual_type)->getKind())
2238        {
2239        case clang::BuiltinType::ObjCId:    // child is Class
2240        case clang::BuiltinType::ObjCClass: // child is Class
2241            num_children = 1;
2242            break;
2243
2244        default:
2245            break;
2246        }
2247        break;
2248
2249    case clang::Type::Complex: return 0;
2250
2251    case clang::Type::Record:
2252        if (GetCompleteQualType (ast, qual_type))
2253        {
2254            const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
2255            const RecordDecl *record_decl = record_type->getDecl();
2256            assert(record_decl);
2257            const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2258            if (cxx_record_decl)
2259            {
2260                if (omit_empty_base_classes)
2261                {
2262                    // Check each base classes to see if it or any of its
2263                    // base classes contain any fields. This can help
2264                    // limit the noise in variable views by not having to
2265                    // show base classes that contain no members.
2266                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2267                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2268                         base_class != base_class_end;
2269                         ++base_class)
2270                    {
2271                        const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2272
2273                        // Skip empty base classes
2274                        if (RecordHasFields(base_class_decl) == false)
2275                            continue;
2276
2277                        num_children++;
2278                    }
2279                }
2280                else
2281                {
2282                    // Include all base classes
2283                    num_children += cxx_record_decl->getNumBases();
2284                }
2285
2286            }
2287            RecordDecl::field_iterator field, field_end;
2288            for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field)
2289                ++num_children;
2290        }
2291        break;
2292
2293    case clang::Type::ObjCObject:
2294    case clang::Type::ObjCInterface:
2295        if (GetCompleteQualType (ast, qual_type))
2296        {
2297            const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
2298            assert (objc_class_type);
2299            if (objc_class_type)
2300            {
2301                ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2302
2303                if (class_interface_decl)
2304                {
2305
2306                    ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2307                    if (superclass_interface_decl)
2308                    {
2309                        if (omit_empty_base_classes)
2310                        {
2311                            if (ClangASTContext::ObjCDeclHasIVars (superclass_interface_decl, true))
2312                                ++num_children;
2313                        }
2314                        else
2315                            ++num_children;
2316                    }
2317
2318                    num_children += class_interface_decl->ivar_size();
2319                }
2320            }
2321        }
2322        break;
2323
2324    case clang::Type::ObjCObjectPointer:
2325        {
2326            const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(qual_type.getTypePtr());
2327            QualType pointee_type = pointer_type->getPointeeType();
2328            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2329                                                                             pointee_type.getAsOpaquePtr(),
2330                                                                             omit_empty_base_classes);
2331            // If this type points to a simple type, then it has 1 child
2332            if (num_pointee_children == 0)
2333                num_children = 1;
2334            else
2335                num_children = num_pointee_children;
2336        }
2337        break;
2338
2339    case clang::Type::ConstantArray:
2340        num_children = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
2341        break;
2342
2343    case clang::Type::Pointer:
2344        {
2345            const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
2346            QualType pointee_type (pointer_type->getPointeeType());
2347            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2348                                                                             pointee_type.getAsOpaquePtr(),
2349                                                                             omit_empty_base_classes);
2350            if (num_pointee_children == 0)
2351            {
2352                // We have a pointer to a pointee type that claims it has no children.
2353                // We will want to look at
2354                num_children = ClangASTContext::GetNumPointeeChildren (pointee_type.getAsOpaquePtr());
2355            }
2356            else
2357                num_children = num_pointee_children;
2358        }
2359        break;
2360
2361    case clang::Type::LValueReference:
2362    case clang::Type::RValueReference:
2363        {
2364            const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
2365            QualType pointee_type = reference_type->getPointeeType();
2366            uint32_t num_pointee_children = ClangASTContext::GetNumChildren (ast,
2367                                                                             pointee_type.getAsOpaquePtr(),
2368                                                                             omit_empty_base_classes);
2369            // If this type points to a simple type, then it has 1 child
2370            if (num_pointee_children == 0)
2371                num_children = 1;
2372            else
2373                num_children = num_pointee_children;
2374        }
2375        break;
2376
2377
2378    case clang::Type::Typedef:
2379        num_children = ClangASTContext::GetNumChildren (ast,
2380                                                        cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2381                                                        omit_empty_base_classes);
2382        break;
2383
2384    default:
2385        break;
2386    }
2387    return num_children;
2388}
2389
2390// If a pointer to a pointee type (the clang_type arg) says that it has no
2391// children, then we either need to trust it, or override it and return a
2392// different result. For example, an "int *" has one child that is an integer,
2393// but a function pointer doesn't have any children. Likewise if a Record type
2394// claims it has no children, then there really is nothing to show.
2395uint32_t
2396ClangASTContext::GetNumPointeeChildren (clang_type_t clang_type)
2397{
2398    if (clang_type == NULL)
2399        return 0;
2400
2401    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
2402    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
2403    switch (type_class)
2404    {
2405    case clang::Type::Builtin:
2406        switch (cast<clang::BuiltinType>(qual_type)->getKind())
2407        {
2408        case clang::BuiltinType::UnknownAny:
2409        case clang::BuiltinType::Void:
2410        case clang::BuiltinType::NullPtr:
2411            return 0;
2412        case clang::BuiltinType::Bool:
2413        case clang::BuiltinType::Char_U:
2414        case clang::BuiltinType::UChar:
2415        case clang::BuiltinType::WChar_U:
2416        case clang::BuiltinType::Char16:
2417        case clang::BuiltinType::Char32:
2418        case clang::BuiltinType::UShort:
2419        case clang::BuiltinType::UInt:
2420        case clang::BuiltinType::ULong:
2421        case clang::BuiltinType::ULongLong:
2422        case clang::BuiltinType::UInt128:
2423        case clang::BuiltinType::Char_S:
2424        case clang::BuiltinType::SChar:
2425        case clang::BuiltinType::WChar_S:
2426        case clang::BuiltinType::Short:
2427        case clang::BuiltinType::Int:
2428        case clang::BuiltinType::Long:
2429        case clang::BuiltinType::LongLong:
2430        case clang::BuiltinType::Int128:
2431        case clang::BuiltinType::Float:
2432        case clang::BuiltinType::Double:
2433        case clang::BuiltinType::LongDouble:
2434        case clang::BuiltinType::Dependent:
2435        case clang::BuiltinType::Overload:
2436        case clang::BuiltinType::ObjCId:
2437        case clang::BuiltinType::ObjCClass:
2438        case clang::BuiltinType::ObjCSel:
2439        case clang::BuiltinType::BoundMember:
2440            return 1;
2441        }
2442        break;
2443
2444    case clang::Type::Complex:                  return 1;
2445    case clang::Type::Pointer:                  return 1;
2446    case clang::Type::BlockPointer:             return 0;   // If block pointers don't have debug info, then no children for them
2447    case clang::Type::LValueReference:          return 1;
2448    case clang::Type::RValueReference:          return 1;
2449    case clang::Type::MemberPointer:            return 0;
2450    case clang::Type::ConstantArray:            return 0;
2451    case clang::Type::IncompleteArray:          return 0;
2452    case clang::Type::VariableArray:            return 0;
2453    case clang::Type::DependentSizedArray:      return 0;
2454    case clang::Type::DependentSizedExtVector:  return 0;
2455    case clang::Type::Vector:                   return 0;
2456    case clang::Type::ExtVector:                return 0;
2457    case clang::Type::FunctionProto:            return 0;   // When we function pointers, they have no children...
2458    case clang::Type::FunctionNoProto:          return 0;   // When we function pointers, they have no children...
2459    case clang::Type::UnresolvedUsing:          return 0;
2460    case clang::Type::Paren:                    return 0;
2461    case clang::Type::Typedef:                  return ClangASTContext::GetNumPointeeChildren (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
2462    case clang::Type::TypeOfExpr:               return 0;
2463    case clang::Type::TypeOf:                   return 0;
2464    case clang::Type::Decltype:                 return 0;
2465    case clang::Type::Record:                   return 0;
2466    case clang::Type::Enum:                     return 1;
2467    case clang::Type::Elaborated:               return 1;
2468    case clang::Type::TemplateTypeParm:         return 1;
2469    case clang::Type::SubstTemplateTypeParm:    return 1;
2470    case clang::Type::TemplateSpecialization:   return 1;
2471    case clang::Type::InjectedClassName:        return 0;
2472    case clang::Type::DependentName:            return 1;
2473    case clang::Type::DependentTemplateSpecialization:  return 1;
2474    case clang::Type::ObjCObject:               return 0;
2475    case clang::Type::ObjCInterface:            return 0;
2476    case clang::Type::ObjCObjectPointer:        return 1;
2477    default:
2478        break;
2479    }
2480    return 0;
2481}
2482
2483clang_type_t
2484ClangASTContext::GetChildClangTypeAtIndex
2485(
2486    ExecutionContext *exe_ctx,
2487    const char *parent_name,
2488    clang_type_t parent_clang_type,
2489    uint32_t idx,
2490    bool transparent_pointers,
2491    bool omit_empty_base_classes,
2492    bool ignore_array_bounds,
2493    std::string& child_name,
2494    uint32_t &child_byte_size,
2495    int32_t &child_byte_offset,
2496    uint32_t &child_bitfield_bit_size,
2497    uint32_t &child_bitfield_bit_offset,
2498    bool &child_is_base_class,
2499    bool &child_is_deref_of_parent
2500)
2501{
2502    if (parent_clang_type)
2503
2504        return GetChildClangTypeAtIndex (exe_ctx,
2505                                         getASTContext(),
2506                                         parent_name,
2507                                         parent_clang_type,
2508                                         idx,
2509                                         transparent_pointers,
2510                                         omit_empty_base_classes,
2511                                         ignore_array_bounds,
2512                                         child_name,
2513                                         child_byte_size,
2514                                         child_byte_offset,
2515                                         child_bitfield_bit_size,
2516                                         child_bitfield_bit_offset,
2517                                         child_is_base_class,
2518                                         child_is_deref_of_parent);
2519    return NULL;
2520}
2521
2522clang_type_t
2523ClangASTContext::GetChildClangTypeAtIndex
2524(
2525    ExecutionContext *exe_ctx,
2526    ASTContext *ast,
2527    const char *parent_name,
2528    clang_type_t parent_clang_type,
2529    uint32_t idx,
2530    bool transparent_pointers,
2531    bool omit_empty_base_classes,
2532    bool ignore_array_bounds,
2533    std::string& child_name,
2534    uint32_t &child_byte_size,
2535    int32_t &child_byte_offset,
2536    uint32_t &child_bitfield_bit_size,
2537    uint32_t &child_bitfield_bit_offset,
2538    bool &child_is_base_class,
2539    bool &child_is_deref_of_parent
2540)
2541{
2542    if (parent_clang_type == NULL)
2543        return NULL;
2544
2545    if (idx < ClangASTContext::GetNumChildren (ast, parent_clang_type, omit_empty_base_classes))
2546    {
2547        uint32_t bit_offset;
2548        child_bitfield_bit_size = 0;
2549        child_bitfield_bit_offset = 0;
2550        child_is_base_class = false;
2551        QualType parent_qual_type(QualType::getFromOpaquePtr(parent_clang_type));
2552        const clang::Type::TypeClass parent_type_class = parent_qual_type->getTypeClass();
2553        switch (parent_type_class)
2554        {
2555        case clang::Type::Builtin:
2556            switch (cast<clang::BuiltinType>(parent_qual_type)->getKind())
2557            {
2558            case clang::BuiltinType::ObjCId:
2559            case clang::BuiltinType::ObjCClass:
2560                child_name = "isa";
2561                child_byte_size = ast->getTypeSize(ast->ObjCBuiltinClassTy) / CHAR_BIT;
2562                return ast->ObjCBuiltinClassTy.getAsOpaquePtr();
2563
2564            default:
2565                break;
2566            }
2567            break;
2568
2569        case clang::Type::Record:
2570            if (GetCompleteQualType (ast, parent_qual_type))
2571            {
2572                const RecordType *record_type = cast<RecordType>(parent_qual_type.getTypePtr());
2573                const RecordDecl *record_decl = record_type->getDecl();
2574                assert(record_decl);
2575                const ASTRecordLayout &record_layout = ast->getASTRecordLayout(record_decl);
2576                uint32_t child_idx = 0;
2577
2578                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2579                if (cxx_record_decl)
2580                {
2581                    // We might have base classes to print out first
2582                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2583                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2584                         base_class != base_class_end;
2585                         ++base_class)
2586                    {
2587                        const CXXRecordDecl *base_class_decl = NULL;
2588
2589                        // Skip empty base classes
2590                        if (omit_empty_base_classes)
2591                        {
2592                            base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2593                            if (RecordHasFields(base_class_decl) == false)
2594                                continue;
2595                        }
2596
2597                        if (idx == child_idx)
2598                        {
2599                            if (base_class_decl == NULL)
2600                                base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
2601
2602
2603                            if (base_class->isVirtual())
2604                                bit_offset = record_layout.getVBaseClassOffset(base_class_decl).getQuantity() * 8;
2605                            else
2606                                bit_offset = record_layout.getBaseClassOffset(base_class_decl).getQuantity() * 8;
2607
2608                            // Base classes should be a multiple of 8 bits in size
2609                            assert (bit_offset % 8 == 0);
2610                            child_byte_offset = bit_offset/8;
2611
2612                            child_name = ClangASTType::GetTypeNameForQualType(base_class->getType());
2613
2614                            uint64_t clang_type_info_bit_size = ast->getTypeSize(base_class->getType());
2615
2616                            // Base classes bit sizes should be a multiple of 8 bits in size
2617                            assert (clang_type_info_bit_size % 8 == 0);
2618                            child_byte_size = clang_type_info_bit_size / 8;
2619                            child_is_base_class = true;
2620                            return base_class->getType().getAsOpaquePtr();
2621                        }
2622                        // We don't increment the child index in the for loop since we might
2623                        // be skipping empty base classes
2624                        ++child_idx;
2625                    }
2626                }
2627                // Make sure index is in range...
2628                uint32_t field_idx = 0;
2629                RecordDecl::field_iterator field, field_end;
2630                for (field = record_decl->field_begin(), field_end = record_decl->field_end(); field != field_end; ++field, ++field_idx, ++child_idx)
2631                {
2632                    if (idx == child_idx)
2633                    {
2634                        // Print the member type if requested
2635                        // Print the member name and equal sign
2636                        child_name.assign(field->getNameAsString().c_str());
2637
2638                        // Figure out the type byte size (field_type_info.first) and
2639                        // alignment (field_type_info.second) from the AST context.
2640                        std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(field->getType());
2641                        assert(field_idx < record_layout.getFieldCount());
2642
2643                        child_byte_size = field_type_info.first / 8;
2644
2645                        // Figure out the field offset within the current struct/union/class type
2646                        bit_offset = record_layout.getFieldOffset (field_idx);
2647                        child_byte_offset = bit_offset / 8;
2648                        if (ClangASTContext::FieldIsBitfield (ast, *field, child_bitfield_bit_size))
2649                            child_bitfield_bit_offset = bit_offset % 8;
2650
2651                        return field->getType().getAsOpaquePtr();
2652                    }
2653                }
2654            }
2655            break;
2656
2657        case clang::Type::ObjCObject:
2658        case clang::Type::ObjCInterface:
2659            if (GetCompleteQualType (ast, parent_qual_type))
2660            {
2661                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(parent_qual_type.getTypePtr());
2662                assert (objc_class_type);
2663                if (objc_class_type)
2664                {
2665                    uint32_t child_idx = 0;
2666                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
2667
2668                    if (class_interface_decl)
2669                    {
2670
2671                        const ASTRecordLayout &interface_layout = ast->getASTObjCInterfaceLayout(class_interface_decl);
2672                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
2673                        if (superclass_interface_decl)
2674                        {
2675                            if (omit_empty_base_classes)
2676                            {
2677                                if (ClangASTContext::GetNumChildren(ast, ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(), omit_empty_base_classes) > 0)
2678                                {
2679                                    if (idx == 0)
2680                                    {
2681                                        QualType ivar_qual_type(ast->getObjCInterfaceType(superclass_interface_decl));
2682
2683
2684                                        child_name.assign(superclass_interface_decl->getNameAsString().c_str());
2685
2686                                        std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
2687
2688                                        child_byte_size = ivar_type_info.first / 8;
2689                                        child_byte_offset = 0;
2690                                        child_is_base_class = true;
2691
2692                                        return ivar_qual_type.getAsOpaquePtr();
2693                                    }
2694
2695                                    ++child_idx;
2696                                }
2697                            }
2698                            else
2699                                ++child_idx;
2700                        }
2701
2702                        const uint32_t superclass_idx = child_idx;
2703
2704                        if (idx < (child_idx + class_interface_decl->ivar_size()))
2705                        {
2706                            ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
2707
2708                            for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
2709                            {
2710                                if (child_idx == idx)
2711                                {
2712                                    const ObjCIvarDecl* ivar_decl = *ivar_pos;
2713
2714                                    QualType ivar_qual_type(ivar_decl->getType());
2715
2716                                    child_name.assign(ivar_decl->getNameAsString().c_str());
2717
2718                                    std::pair<uint64_t, unsigned> ivar_type_info = ast->getTypeInfo(ivar_qual_type.getTypePtr());
2719
2720                                    child_byte_size = ivar_type_info.first / 8;
2721
2722                                    // Figure out the field offset within the current struct/union/class type
2723                                    // For ObjC objects, we can't trust the bit offset we get from the Clang AST, since
2724                                    // that doesn't account for the space taken up by unbacked properties, or from
2725                                    // the changing size of base classes that are newer than this class.
2726                                    // So if we have a process around that we can ask about this object, do so.
2727                                    child_byte_offset = LLDB_INVALID_IVAR_OFFSET;
2728
2729                                    if (exe_ctx && exe_ctx->process)
2730                                    {
2731                                        ObjCLanguageRuntime *objc_runtime = exe_ctx->process->GetObjCLanguageRuntime();
2732                                        if (objc_runtime != NULL)
2733                                        {
2734                                            ClangASTType parent_ast_type (ast, parent_qual_type.getAsOpaquePtr());
2735                                            child_byte_offset = objc_runtime->GetByteOffsetForIvar (parent_ast_type, ivar_decl->getNameAsString().c_str());
2736                                        }
2737                                    }
2738
2739                                    if (child_byte_offset == LLDB_INVALID_IVAR_OFFSET)
2740                                    {
2741                                        bit_offset = interface_layout.getFieldOffset (child_idx - superclass_idx);
2742                                        child_byte_offset = bit_offset / 8;
2743                                    }
2744
2745                                    return ivar_qual_type.getAsOpaquePtr();
2746                                }
2747                                ++child_idx;
2748                            }
2749                        }
2750                    }
2751                }
2752            }
2753            break;
2754
2755        case clang::Type::ObjCObjectPointer:
2756            {
2757                const ObjCObjectPointerType *pointer_type = cast<ObjCObjectPointerType>(parent_qual_type.getTypePtr());
2758                QualType pointee_type = pointer_type->getPointeeType();
2759
2760                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2761                {
2762                    child_is_deref_of_parent = false;
2763                    bool tmp_child_is_deref_of_parent = false;
2764                    return GetChildClangTypeAtIndex (exe_ctx,
2765                                                     ast,
2766                                                     parent_name,
2767                                                     pointer_type->getPointeeType().getAsOpaquePtr(),
2768                                                     idx,
2769                                                     transparent_pointers,
2770                                                     omit_empty_base_classes,
2771                                                     ignore_array_bounds,
2772                                                     child_name,
2773                                                     child_byte_size,
2774                                                     child_byte_offset,
2775                                                     child_bitfield_bit_size,
2776                                                     child_bitfield_bit_offset,
2777                                                     child_is_base_class,
2778                                                     tmp_child_is_deref_of_parent);
2779                }
2780                else
2781                {
2782                    child_is_deref_of_parent = true;
2783                    if (parent_name)
2784                    {
2785                        child_name.assign(1, '*');
2786                        child_name += parent_name;
2787                    }
2788
2789                    // We have a pointer to an simple type
2790                    if (idx == 0)
2791                    {
2792                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
2793                        assert(clang_type_info.first % 8 == 0);
2794                        child_byte_size = clang_type_info.first / 8;
2795                        child_byte_offset = 0;
2796                        return pointee_type.getAsOpaquePtr();
2797                    }
2798                }
2799            }
2800            break;
2801
2802        case clang::Type::ConstantArray:
2803            {
2804                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
2805                const uint64_t element_count = array->getSize().getLimitedValue();
2806
2807                if (ignore_array_bounds || idx < element_count)
2808                {
2809                    if (GetCompleteQualType (ast, array->getElementType()))
2810                    {
2811                        std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
2812
2813                        char element_name[64];
2814                        ::snprintf (element_name, sizeof (element_name), "[%u]", idx);
2815
2816                        child_name.assign(element_name);
2817                        assert(field_type_info.first % 8 == 0);
2818                        child_byte_size = field_type_info.first / 8;
2819                        child_byte_offset = (int32_t)idx * (int32_t)child_byte_size;
2820                        return array->getElementType().getAsOpaquePtr();
2821                    }
2822                }
2823            }
2824            break;
2825
2826        case clang::Type::Pointer:
2827            {
2828                const PointerType *pointer_type = cast<PointerType>(parent_qual_type.getTypePtr());
2829                QualType pointee_type = pointer_type->getPointeeType();
2830
2831                // Don't dereference "void *" pointers
2832                if (pointee_type->isVoidType())
2833                    return NULL;
2834
2835                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
2836                {
2837                    child_is_deref_of_parent = false;
2838                    bool tmp_child_is_deref_of_parent = false;
2839                    return GetChildClangTypeAtIndex (exe_ctx,
2840                                                     ast,
2841                                                     parent_name,
2842                                                     pointer_type->getPointeeType().getAsOpaquePtr(),
2843                                                     idx,
2844                                                     transparent_pointers,
2845                                                     omit_empty_base_classes,
2846                                                     ignore_array_bounds,
2847                                                     child_name,
2848                                                     child_byte_size,
2849                                                     child_byte_offset,
2850                                                     child_bitfield_bit_size,
2851                                                     child_bitfield_bit_offset,
2852                                                     child_is_base_class,
2853                                                     tmp_child_is_deref_of_parent);
2854                }
2855                else
2856                {
2857                    child_is_deref_of_parent = true;
2858
2859                    if (parent_name)
2860                    {
2861                        child_name.assign(1, '*');
2862                        child_name += parent_name;
2863                    }
2864
2865                    // We have a pointer to an simple type
2866                    if (idx == 0)
2867                    {
2868                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
2869                        assert(clang_type_info.first % 8 == 0);
2870                        child_byte_size = clang_type_info.first / 8;
2871                        child_byte_offset = 0;
2872                        return pointee_type.getAsOpaquePtr();
2873                    }
2874                }
2875            }
2876            break;
2877
2878        case clang::Type::LValueReference:
2879        case clang::Type::RValueReference:
2880            {
2881                const ReferenceType *reference_type = cast<ReferenceType>(parent_qual_type.getTypePtr());
2882                QualType pointee_type(reference_type->getPointeeType());
2883                clang_type_t pointee_clang_type = pointee_type.getAsOpaquePtr();
2884                if (transparent_pointers && ClangASTContext::IsAggregateType (pointee_clang_type))
2885                {
2886                    child_is_deref_of_parent = false;
2887                    bool tmp_child_is_deref_of_parent = false;
2888                    return GetChildClangTypeAtIndex (exe_ctx,
2889                                                     ast,
2890                                                     parent_name,
2891                                                     pointee_clang_type,
2892                                                     idx,
2893                                                     transparent_pointers,
2894                                                     omit_empty_base_classes,
2895                                                     ignore_array_bounds,
2896                                                     child_name,
2897                                                     child_byte_size,
2898                                                     child_byte_offset,
2899                                                     child_bitfield_bit_size,
2900                                                     child_bitfield_bit_offset,
2901                                                     child_is_base_class,
2902                                                     tmp_child_is_deref_of_parent);
2903                }
2904                else
2905                {
2906                    if (parent_name)
2907                    {
2908                        child_name.assign(1, '&');
2909                        child_name += parent_name;
2910                    }
2911
2912                    // We have a pointer to an simple type
2913                    if (idx == 0)
2914                    {
2915                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
2916                        assert(clang_type_info.first % 8 == 0);
2917                        child_byte_size = clang_type_info.first / 8;
2918                        child_byte_offset = 0;
2919                        return pointee_type.getAsOpaquePtr();
2920                    }
2921                }
2922            }
2923            break;
2924
2925        case clang::Type::Typedef:
2926            return GetChildClangTypeAtIndex (exe_ctx,
2927                                             ast,
2928                                             parent_name,
2929                                             cast<TypedefType>(parent_qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
2930                                             idx,
2931                                             transparent_pointers,
2932                                             omit_empty_base_classes,
2933                                             ignore_array_bounds,
2934                                             child_name,
2935                                             child_byte_size,
2936                                             child_byte_offset,
2937                                             child_bitfield_bit_size,
2938                                             child_bitfield_bit_offset,
2939                                             child_is_base_class,
2940                                             child_is_deref_of_parent);
2941            break;
2942
2943        default:
2944            break;
2945        }
2946    }
2947    return NULL;
2948}
2949
2950static inline bool
2951BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
2952{
2953    return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
2954}
2955
2956static uint32_t
2957GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
2958{
2959    uint32_t num_bases = 0;
2960    if (cxx_record_decl)
2961    {
2962        if (omit_empty_base_classes)
2963        {
2964            CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
2965            for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
2966                 base_class != base_class_end;
2967                 ++base_class)
2968            {
2969                // Skip empty base classes
2970                if (omit_empty_base_classes)
2971                {
2972                    if (BaseSpecifierIsEmpty (base_class))
2973                        continue;
2974                }
2975                ++num_bases;
2976            }
2977        }
2978        else
2979            num_bases = cxx_record_decl->getNumBases();
2980    }
2981    return num_bases;
2982}
2983
2984
2985static uint32_t
2986GetIndexForRecordBase
2987(
2988    const RecordDecl *record_decl,
2989    const CXXBaseSpecifier *base_spec,
2990    bool omit_empty_base_classes
2991)
2992{
2993    uint32_t child_idx = 0;
2994
2995    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
2996
2997//    const char *super_name = record_decl->getNameAsCString();
2998//    const char *base_name = base_spec->getType()->getAs<RecordType>()->getDecl()->getNameAsCString();
2999//    printf ("GetIndexForRecordChild (%s, %s)\n", super_name, base_name);
3000//
3001    if (cxx_record_decl)
3002    {
3003        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3004        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3005             base_class != base_class_end;
3006             ++base_class)
3007        {
3008            if (omit_empty_base_classes)
3009            {
3010                if (BaseSpecifierIsEmpty (base_class))
3011                    continue;
3012            }
3013
3014//            printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n", super_name, base_name,
3015//                    child_idx,
3016//                    base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
3017//
3018//
3019            if (base_class == base_spec)
3020                return child_idx;
3021            ++child_idx;
3022        }
3023    }
3024
3025    return UINT32_MAX;
3026}
3027
3028
3029static uint32_t
3030GetIndexForRecordChild
3031(
3032    const RecordDecl *record_decl,
3033    NamedDecl *canonical_decl,
3034    bool omit_empty_base_classes
3035)
3036{
3037    uint32_t child_idx = GetNumBaseClasses (dyn_cast<CXXRecordDecl>(record_decl), omit_empty_base_classes);
3038
3039//    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3040//
3041////    printf ("GetIndexForRecordChild (%s, %s)\n", record_decl->getNameAsCString(), canonical_decl->getNameAsCString());
3042//    if (cxx_record_decl)
3043//    {
3044//        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3045//        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3046//             base_class != base_class_end;
3047//             ++base_class)
3048//        {
3049//            if (omit_empty_base_classes)
3050//            {
3051//                if (BaseSpecifierIsEmpty (base_class))
3052//                    continue;
3053//            }
3054//
3055////            printf ("GetIndexForRecordChild (%s, %s) base[%u] = %s\n",
3056////                    record_decl->getNameAsCString(),
3057////                    canonical_decl->getNameAsCString(),
3058////                    child_idx,
3059////                    base_class->getType()->getAs<RecordType>()->getDecl()->getNameAsCString());
3060//
3061//
3062//            CXXRecordDecl *curr_base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3063//            if (curr_base_class_decl == canonical_decl)
3064//            {
3065//                return child_idx;
3066//            }
3067//            ++child_idx;
3068//        }
3069//    }
3070//
3071//    const uint32_t num_bases = child_idx;
3072    RecordDecl::field_iterator field, field_end;
3073    for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3074         field != field_end;
3075         ++field, ++child_idx)
3076    {
3077//            printf ("GetIndexForRecordChild (%s, %s) field[%u] = %s\n",
3078//                    record_decl->getNameAsCString(),
3079//                    canonical_decl->getNameAsCString(),
3080//                    child_idx - num_bases,
3081//                    field->getNameAsCString());
3082
3083        if (field->getCanonicalDecl() == canonical_decl)
3084            return child_idx;
3085    }
3086
3087    return UINT32_MAX;
3088}
3089
3090// Look for a child member (doesn't include base classes, but it does include
3091// their members) in the type hierarchy. Returns an index path into "clang_type"
3092// on how to reach the appropriate member.
3093//
3094//    class A
3095//    {
3096//    public:
3097//        int m_a;
3098//        int m_b;
3099//    };
3100//
3101//    class B
3102//    {
3103//    };
3104//
3105//    class C :
3106//        public B,
3107//        public A
3108//    {
3109//    };
3110//
3111// If we have a clang type that describes "class C", and we wanted to looked
3112// "m_b" in it:
3113//
3114// With omit_empty_base_classes == false we would get an integer array back with:
3115// { 1,  1 }
3116// The first index 1 is the child index for "class A" within class C
3117// The second index 1 is the child index for "m_b" within class A
3118//
3119// With omit_empty_base_classes == true we would get an integer array back with:
3120// { 0,  1 }
3121// 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)
3122// The second index 1 is the child index for "m_b" within class A
3123
3124size_t
3125ClangASTContext::GetIndexOfChildMemberWithName
3126(
3127    ASTContext *ast,
3128    clang_type_t clang_type,
3129    const char *name,
3130    bool omit_empty_base_classes,
3131    std::vector<uint32_t>& child_indexes
3132)
3133{
3134    if (clang_type && name && name[0])
3135    {
3136        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3137        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3138        switch (type_class)
3139        {
3140        case clang::Type::Record:
3141            if (GetCompleteQualType (ast, qual_type))
3142            {
3143                const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3144                const RecordDecl *record_decl = record_type->getDecl();
3145
3146                assert(record_decl);
3147                uint32_t child_idx = 0;
3148
3149                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3150
3151                // Try and find a field that matches NAME
3152                RecordDecl::field_iterator field, field_end;
3153                StringRef name_sref(name);
3154                for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3155                     field != field_end;
3156                     ++field, ++child_idx)
3157                {
3158                    if (field->getName().equals (name_sref))
3159                    {
3160                        // We have to add on the number of base classes to this index!
3161                        child_indexes.push_back (child_idx + GetNumBaseClasses (cxx_record_decl, omit_empty_base_classes));
3162                        return child_indexes.size();
3163                    }
3164                }
3165
3166                if (cxx_record_decl)
3167                {
3168                    const RecordDecl *parent_record_decl = cxx_record_decl;
3169
3170                    //printf ("parent = %s\n", parent_record_decl->getNameAsCString());
3171
3172                    //const Decl *root_cdecl = cxx_record_decl->getCanonicalDecl();
3173                    // Didn't find things easily, lets let clang do its thang...
3174                    IdentifierInfo & ident_ref = ast->Idents.get(name_sref);
3175                    DeclarationName decl_name(&ident_ref);
3176
3177                    CXXBasePaths paths;
3178                    if (cxx_record_decl->lookupInBases(CXXRecordDecl::FindOrdinaryMember,
3179                                                       decl_name.getAsOpaquePtr(),
3180                                                       paths))
3181                    {
3182                        CXXBasePaths::const_paths_iterator path, path_end = paths.end();
3183                        for (path = paths.begin(); path != path_end; ++path)
3184                        {
3185                            const size_t num_path_elements = path->size();
3186                            for (size_t e=0; e<num_path_elements; ++e)
3187                            {
3188                                CXXBasePathElement elem = (*path)[e];
3189
3190                                child_idx = GetIndexForRecordBase (parent_record_decl, elem.Base, omit_empty_base_classes);
3191                                if (child_idx == UINT32_MAX)
3192                                {
3193                                    child_indexes.clear();
3194                                    return 0;
3195                                }
3196                                else
3197                                {
3198                                    child_indexes.push_back (child_idx);
3199                                    parent_record_decl = cast<RecordDecl>(elem.Base->getType()->getAs<RecordType>()->getDecl());
3200                                }
3201                            }
3202                            DeclContext::lookup_iterator named_decl_pos;
3203                            for (named_decl_pos = path->Decls.first;
3204                                 named_decl_pos != path->Decls.second && parent_record_decl;
3205                                 ++named_decl_pos)
3206                            {
3207                                //printf ("path[%zu] = %s\n", child_indexes.size(), (*named_decl_pos)->getNameAsCString());
3208
3209                                child_idx = GetIndexForRecordChild (parent_record_decl, *named_decl_pos, omit_empty_base_classes);
3210                                if (child_idx == UINT32_MAX)
3211                                {
3212                                    child_indexes.clear();
3213                                    return 0;
3214                                }
3215                                else
3216                                {
3217                                    child_indexes.push_back (child_idx);
3218                                }
3219                            }
3220                        }
3221                        return child_indexes.size();
3222                    }
3223                }
3224
3225            }
3226            break;
3227
3228        case clang::Type::ObjCObject:
3229        case clang::Type::ObjCInterface:
3230            if (GetCompleteQualType (ast, qual_type))
3231            {
3232                StringRef name_sref(name);
3233                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3234                assert (objc_class_type);
3235                if (objc_class_type)
3236                {
3237                    uint32_t child_idx = 0;
3238                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3239
3240                    if (class_interface_decl)
3241                    {
3242                        ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3243                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3244
3245                        for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos, ++child_idx)
3246                        {
3247                            const ObjCIvarDecl* ivar_decl = *ivar_pos;
3248
3249                            if (ivar_decl->getName().equals (name_sref))
3250                            {
3251                                if ((!omit_empty_base_classes && superclass_interface_decl) ||
3252                                    ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3253                                    ++child_idx;
3254
3255                                child_indexes.push_back (child_idx);
3256                                return child_indexes.size();
3257                            }
3258                        }
3259
3260                        if (superclass_interface_decl)
3261                        {
3262                            // The super class index is always zero for ObjC classes,
3263                            // so we push it onto the child indexes in case we find
3264                            // an ivar in our superclass...
3265                            child_indexes.push_back (0);
3266
3267                            if (GetIndexOfChildMemberWithName (ast,
3268                                                               ast->getObjCInterfaceType(superclass_interface_decl).getAsOpaquePtr(),
3269                                                               name,
3270                                                               omit_empty_base_classes,
3271                                                               child_indexes))
3272                            {
3273                                // We did find an ivar in a superclass so just
3274                                // return the results!
3275                                return child_indexes.size();
3276                            }
3277
3278                            // We didn't find an ivar matching "name" in our
3279                            // superclass, pop the superclass zero index that
3280                            // we pushed on above.
3281                            child_indexes.pop_back();
3282                        }
3283                    }
3284                }
3285            }
3286            break;
3287
3288        case clang::Type::ObjCObjectPointer:
3289            {
3290                return GetIndexOfChildMemberWithName (ast,
3291                                                      cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
3292                                                      name,
3293                                                      omit_empty_base_classes,
3294                                                      child_indexes);
3295            }
3296            break;
3297
3298
3299        case clang::Type::ConstantArray:
3300            {
3301//                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3302//                const uint64_t element_count = array->getSize().getLimitedValue();
3303//
3304//                if (idx < element_count)
3305//                {
3306//                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
3307//
3308//                    char element_name[32];
3309//                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3310//
3311//                    child_name.assign(element_name);
3312//                    assert(field_type_info.first % 8 == 0);
3313//                    child_byte_size = field_type_info.first / 8;
3314//                    child_byte_offset = idx * child_byte_size;
3315//                    return array->getElementType().getAsOpaquePtr();
3316//                }
3317            }
3318            break;
3319
3320//        case clang::Type::MemberPointerType:
3321//            {
3322//                MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3323//                QualType pointee_type = mem_ptr_type->getPointeeType();
3324//
3325//                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3326//                {
3327//                    return GetIndexOfChildWithName (ast,
3328//                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3329//                                                    name);
3330//                }
3331//            }
3332//            break;
3333//
3334        case clang::Type::LValueReference:
3335        case clang::Type::RValueReference:
3336            {
3337                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3338                QualType pointee_type = reference_type->getPointeeType();
3339
3340                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3341                {
3342                    return GetIndexOfChildMemberWithName (ast,
3343                                                          reference_type->getPointeeType().getAsOpaquePtr(),
3344                                                          name,
3345                                                          omit_empty_base_classes,
3346                                                          child_indexes);
3347                }
3348            }
3349            break;
3350
3351        case clang::Type::Pointer:
3352            {
3353                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3354                QualType pointee_type = pointer_type->getPointeeType();
3355
3356                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3357                {
3358                    return GetIndexOfChildMemberWithName (ast,
3359                                                          pointer_type->getPointeeType().getAsOpaquePtr(),
3360                                                          name,
3361                                                          omit_empty_base_classes,
3362                                                          child_indexes);
3363                }
3364                else
3365                {
3366//                    if (parent_name)
3367//                    {
3368//                        child_name.assign(1, '*');
3369//                        child_name += parent_name;
3370//                    }
3371//
3372//                    // We have a pointer to an simple type
3373//                    if (idx == 0)
3374//                    {
3375//                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
3376//                        assert(clang_type_info.first % 8 == 0);
3377//                        child_byte_size = clang_type_info.first / 8;
3378//                        child_byte_offset = 0;
3379//                        return pointee_type.getAsOpaquePtr();
3380//                    }
3381                }
3382            }
3383            break;
3384
3385        case clang::Type::Typedef:
3386            return GetIndexOfChildMemberWithName (ast,
3387                                                  cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3388                                                  name,
3389                                                  omit_empty_base_classes,
3390                                                  child_indexes);
3391
3392        default:
3393            break;
3394        }
3395    }
3396    return 0;
3397}
3398
3399
3400// Get the index of the child of "clang_type" whose name matches. This function
3401// doesn't descend into the children, but only looks one level deep and name
3402// matches can include base class names.
3403
3404uint32_t
3405ClangASTContext::GetIndexOfChildWithName
3406(
3407    ASTContext *ast,
3408    clang_type_t clang_type,
3409    const char *name,
3410    bool omit_empty_base_classes
3411)
3412{
3413    if (clang_type && name && name[0])
3414    {
3415        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3416
3417        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3418
3419        switch (type_class)
3420        {
3421        case clang::Type::Record:
3422            if (GetCompleteQualType (ast, qual_type))
3423            {
3424                const RecordType *record_type = cast<RecordType>(qual_type.getTypePtr());
3425                const RecordDecl *record_decl = record_type->getDecl();
3426
3427                assert(record_decl);
3428                uint32_t child_idx = 0;
3429
3430                const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
3431
3432                if (cxx_record_decl)
3433                {
3434                    CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
3435                    for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
3436                         base_class != base_class_end;
3437                         ++base_class)
3438                    {
3439                        // Skip empty base classes
3440                        CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
3441                        if (omit_empty_base_classes && RecordHasFields(base_class_decl) == false)
3442                            continue;
3443
3444                        std::string base_class_type_name (ClangASTType::GetTypeNameForQualType(base_class->getType()));
3445                        if (base_class_type_name.compare (name) == 0)
3446                            return child_idx;
3447                        ++child_idx;
3448                    }
3449                }
3450
3451                // Try and find a field that matches NAME
3452                RecordDecl::field_iterator field, field_end;
3453                StringRef name_sref(name);
3454                for (field = record_decl->field_begin(), field_end = record_decl->field_end();
3455                     field != field_end;
3456                     ++field, ++child_idx)
3457                {
3458                    if (field->getName().equals (name_sref))
3459                        return child_idx;
3460                }
3461
3462            }
3463            break;
3464
3465        case clang::Type::ObjCObject:
3466        case clang::Type::ObjCInterface:
3467            if (GetCompleteQualType (ast, qual_type))
3468            {
3469                StringRef name_sref(name);
3470                const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type.getTypePtr());
3471                assert (objc_class_type);
3472                if (objc_class_type)
3473                {
3474                    uint32_t child_idx = 0;
3475                    ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3476
3477                    if (class_interface_decl)
3478                    {
3479                        ObjCInterfaceDecl::ivar_iterator ivar_pos, ivar_end = class_interface_decl->ivar_end();
3480                        ObjCInterfaceDecl *superclass_interface_decl = class_interface_decl->getSuperClass();
3481
3482                        for (ivar_pos = class_interface_decl->ivar_begin(); ivar_pos != ivar_end; ++ivar_pos)
3483                        {
3484                            const ObjCIvarDecl* ivar_decl = *ivar_pos;
3485
3486                            if (ivar_decl->getName().equals (name_sref))
3487                            {
3488                                if ((!omit_empty_base_classes && superclass_interface_decl) ||
3489                                    ( omit_empty_base_classes && ObjCDeclHasIVars (superclass_interface_decl, true)))
3490                                    ++child_idx;
3491
3492                                return child_idx;
3493                            }
3494                        }
3495
3496                        if (superclass_interface_decl)
3497                        {
3498                            if (superclass_interface_decl->getName().equals (name_sref))
3499                                return 0;
3500                        }
3501                    }
3502                }
3503            }
3504            break;
3505
3506        case clang::Type::ObjCObjectPointer:
3507            {
3508                return GetIndexOfChildWithName (ast,
3509                                                cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr(),
3510                                                name,
3511                                                omit_empty_base_classes);
3512            }
3513            break;
3514
3515        case clang::Type::ConstantArray:
3516            {
3517//                const ConstantArrayType *array = cast<ConstantArrayType>(parent_qual_type.getTypePtr());
3518//                const uint64_t element_count = array->getSize().getLimitedValue();
3519//
3520//                if (idx < element_count)
3521//                {
3522//                    std::pair<uint64_t, unsigned> field_type_info = ast->getTypeInfo(array->getElementType());
3523//
3524//                    char element_name[32];
3525//                    ::snprintf (element_name, sizeof (element_name), "%s[%u]", parent_name ? parent_name : "", idx);
3526//
3527//                    child_name.assign(element_name);
3528//                    assert(field_type_info.first % 8 == 0);
3529//                    child_byte_size = field_type_info.first / 8;
3530//                    child_byte_offset = idx * child_byte_size;
3531//                    return array->getElementType().getAsOpaquePtr();
3532//                }
3533            }
3534            break;
3535
3536//        case clang::Type::MemberPointerType:
3537//            {
3538//                MemberPointerType *mem_ptr_type = cast<MemberPointerType>(qual_type.getTypePtr());
3539//                QualType pointee_type = mem_ptr_type->getPointeeType();
3540//
3541//                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3542//                {
3543//                    return GetIndexOfChildWithName (ast,
3544//                                                    mem_ptr_type->getPointeeType().getAsOpaquePtr(),
3545//                                                    name);
3546//                }
3547//            }
3548//            break;
3549//
3550        case clang::Type::LValueReference:
3551        case clang::Type::RValueReference:
3552            {
3553                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
3554                QualType pointee_type = reference_type->getPointeeType();
3555
3556                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3557                {
3558                    return GetIndexOfChildWithName (ast,
3559                                                    reference_type->getPointeeType().getAsOpaquePtr(),
3560                                                    name,
3561                                                    omit_empty_base_classes);
3562                }
3563            }
3564            break;
3565
3566        case clang::Type::Pointer:
3567            {
3568                const PointerType *pointer_type = cast<PointerType>(qual_type.getTypePtr());
3569                QualType pointee_type = pointer_type->getPointeeType();
3570
3571                if (ClangASTContext::IsAggregateType (pointee_type.getAsOpaquePtr()))
3572                {
3573                    return GetIndexOfChildWithName (ast,
3574                                                    pointer_type->getPointeeType().getAsOpaquePtr(),
3575                                                    name,
3576                                                    omit_empty_base_classes);
3577                }
3578                else
3579                {
3580//                    if (parent_name)
3581//                    {
3582//                        child_name.assign(1, '*');
3583//                        child_name += parent_name;
3584//                    }
3585//
3586//                    // We have a pointer to an simple type
3587//                    if (idx == 0)
3588//                    {
3589//                        std::pair<uint64_t, unsigned> clang_type_info = ast->getTypeInfo(pointee_type);
3590//                        assert(clang_type_info.first % 8 == 0);
3591//                        child_byte_size = clang_type_info.first / 8;
3592//                        child_byte_offset = 0;
3593//                        return pointee_type.getAsOpaquePtr();
3594//                    }
3595                }
3596            }
3597            break;
3598
3599        case clang::Type::Typedef:
3600            return GetIndexOfChildWithName (ast,
3601                                            cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
3602                                            name,
3603                                            omit_empty_base_classes);
3604
3605        default:
3606            break;
3607        }
3608    }
3609    return UINT32_MAX;
3610}
3611
3612#pragma mark TagType
3613
3614bool
3615ClangASTContext::SetTagTypeKind (clang_type_t tag_clang_type, int kind)
3616{
3617    if (tag_clang_type)
3618    {
3619        QualType tag_qual_type(QualType::getFromOpaquePtr(tag_clang_type));
3620        const clang::Type *clang_type = tag_qual_type.getTypePtr();
3621        if (clang_type)
3622        {
3623            const TagType *tag_type = dyn_cast<TagType>(clang_type);
3624            if (tag_type)
3625            {
3626                TagDecl *tag_decl = dyn_cast<TagDecl>(tag_type->getDecl());
3627                if (tag_decl)
3628                {
3629                    tag_decl->setTagKind ((TagDecl::TagKind)kind);
3630                    return true;
3631                }
3632            }
3633        }
3634    }
3635    return false;
3636}
3637
3638
3639#pragma mark DeclContext Functions
3640
3641DeclContext *
3642ClangASTContext::GetDeclContextForType (clang_type_t clang_type)
3643{
3644    if (clang_type == NULL)
3645        return NULL;
3646
3647    QualType qual_type(QualType::getFromOpaquePtr(clang_type));
3648    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
3649    switch (type_class)
3650    {
3651    case clang::Type::UnaryTransform:           break;
3652    case clang::Type::FunctionNoProto:          break;
3653    case clang::Type::FunctionProto:            break;
3654    case clang::Type::IncompleteArray:          break;
3655    case clang::Type::VariableArray:            break;
3656    case clang::Type::ConstantArray:            break;
3657    case clang::Type::DependentSizedArray:      break;
3658    case clang::Type::ExtVector:                break;
3659    case clang::Type::DependentSizedExtVector:  break;
3660    case clang::Type::Vector:                   break;
3661    case clang::Type::Builtin:                  break;
3662    case clang::Type::BlockPointer:             break;
3663    case clang::Type::Pointer:                  break;
3664    case clang::Type::LValueReference:          break;
3665    case clang::Type::RValueReference:          break;
3666    case clang::Type::MemberPointer:            break;
3667    case clang::Type::Complex:                  break;
3668    case clang::Type::ObjCObject:               break;
3669    case clang::Type::ObjCInterface:            return cast<ObjCObjectType>(qual_type.getTypePtr())->getInterface();
3670    case clang::Type::ObjCObjectPointer:        return ClangASTContext::GetDeclContextForType (cast<ObjCObjectPointerType>(qual_type.getTypePtr())->getPointeeType().getAsOpaquePtr());
3671    case clang::Type::Record:                   return cast<RecordType>(qual_type)->getDecl();
3672    case clang::Type::Enum:                     return cast<EnumType>(qual_type)->getDecl();
3673    case clang::Type::Typedef:                  return ClangASTContext::GetDeclContextForType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
3674
3675    case clang::Type::TypeOfExpr:               break;
3676    case clang::Type::TypeOf:                   break;
3677    case clang::Type::Decltype:                 break;
3678    //case clang::Type::QualifiedName:          break;
3679    case clang::Type::TemplateSpecialization:   break;
3680    case clang::Type::DependentTemplateSpecialization:  break;
3681    case clang::Type::TemplateTypeParm:         break;
3682    case clang::Type::SubstTemplateTypeParm:    break;
3683    case clang::Type::SubstTemplateTypeParmPack:break;
3684    case clang::Type::PackExpansion:            break;
3685    case clang::Type::UnresolvedUsing:          break;
3686    case clang::Type::Paren:                    break;
3687    case clang::Type::Elaborated:               break;
3688    case clang::Type::Attributed:               break;
3689    case clang::Type::Auto:                     break;
3690    case clang::Type::InjectedClassName:        break;
3691    case clang::Type::DependentName:            break;
3692    }
3693    // No DeclContext in this type...
3694    return NULL;
3695}
3696
3697#pragma mark Namespace Declarations
3698
3699NamespaceDecl *
3700ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, const Declaration &decl, DeclContext *decl_ctx)
3701{
3702    // TODO: Do something intelligent with the Declaration object passed in
3703    // like maybe filling in the SourceLocation with it...
3704    if (name)
3705    {
3706        ASTContext *ast = getASTContext();
3707        if (decl_ctx == NULL)
3708            decl_ctx = ast->getTranslationUnitDecl();
3709        return NamespaceDecl::Create(*ast, decl_ctx, SourceLocation(), SourceLocation(), &ast->Idents.get(name));
3710    }
3711    return NULL;
3712}
3713
3714
3715#pragma mark Function Types
3716
3717FunctionDecl *
3718ClangASTContext::CreateFunctionDeclaration (const char *name, clang_type_t function_clang_type, int storage, bool is_inline)
3719{
3720    if (name)
3721    {
3722        ASTContext *ast = getASTContext();
3723        assert (ast != NULL);
3724
3725        if (name && name[0])
3726        {
3727            return FunctionDecl::Create(*ast,
3728                                        ast->getTranslationUnitDecl(),
3729                                        SourceLocation(),
3730                                        SourceLocation(),
3731                                        DeclarationName (&ast->Idents.get(name)),
3732                                        QualType::getFromOpaquePtr(function_clang_type),
3733                                        NULL,
3734                                        (FunctionDecl::StorageClass)storage,
3735                                        (FunctionDecl::StorageClass)storage,
3736                                        is_inline);
3737        }
3738        else
3739        {
3740            return FunctionDecl::Create(*ast,
3741                                        ast->getTranslationUnitDecl(),
3742                                        SourceLocation(),
3743                                        SourceLocation(),
3744                                        DeclarationName (),
3745                                        QualType::getFromOpaquePtr(function_clang_type),
3746                                        NULL,
3747                                        (FunctionDecl::StorageClass)storage,
3748                                        (FunctionDecl::StorageClass)storage,
3749                                        is_inline);
3750        }
3751    }
3752    return NULL;
3753}
3754
3755clang_type_t
3756ClangASTContext::CreateFunctionType (ASTContext *ast,
3757                                     clang_type_t result_type,
3758                                     clang_type_t *args,
3759                                     unsigned num_args,
3760                                     bool is_variadic,
3761                                     unsigned type_quals)
3762{
3763    assert (ast != NULL);
3764    std::vector<QualType> qual_type_args;
3765    for (unsigned i=0; i<num_args; ++i)
3766        qual_type_args.push_back (QualType::getFromOpaquePtr(args[i]));
3767
3768    // TODO: Detect calling convention in DWARF?
3769    FunctionProtoType::ExtProtoInfo proto_info;
3770    proto_info.Variadic = is_variadic;
3771    proto_info.ExceptionSpecType = EST_None;
3772    proto_info.TypeQuals = type_quals;
3773    proto_info.RefQualifier = RQ_None;
3774    proto_info.NumExceptions = 0;
3775    proto_info.Exceptions = NULL;
3776
3777    return ast->getFunctionType(QualType::getFromOpaquePtr(result_type),
3778                                        qual_type_args.empty() ? NULL : &qual_type_args.front(),
3779                                        qual_type_args.size(),
3780                                        proto_info).getAsOpaquePtr();    // NoReturn);
3781}
3782
3783ParmVarDecl *
3784ClangASTContext::CreateParameterDeclaration (const char *name, clang_type_t param_type, int storage)
3785{
3786    ASTContext *ast = getASTContext();
3787    assert (ast != NULL);
3788    return ParmVarDecl::Create(*ast,
3789                                ast->getTranslationUnitDecl(),
3790                                SourceLocation(),
3791                                SourceLocation(),
3792                                name && name[0] ? &ast->Idents.get(name) : NULL,
3793                                QualType::getFromOpaquePtr(param_type),
3794                                NULL,
3795                                (VarDecl::StorageClass)storage,
3796                                (VarDecl::StorageClass)storage,
3797                                0);
3798}
3799
3800void
3801ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
3802{
3803    if (function_decl)
3804        function_decl->setParams (params, num_params);
3805}
3806
3807
3808#pragma mark Array Types
3809
3810clang_type_t
3811ClangASTContext::CreateArrayType (clang_type_t element_type, size_t element_count, uint32_t bit_stride)
3812{
3813    if (element_type)
3814    {
3815        ASTContext *ast = getASTContext();
3816        assert (ast != NULL);
3817        llvm::APInt ap_element_count (64, element_count);
3818        return ast->getConstantArrayType(QualType::getFromOpaquePtr(element_type),
3819                                                 ap_element_count,
3820                                                 ArrayType::Normal,
3821                                                 0).getAsOpaquePtr(); // ElemQuals
3822    }
3823    return NULL;
3824}
3825
3826
3827#pragma mark TagDecl
3828
3829bool
3830ClangASTContext::StartTagDeclarationDefinition (clang_type_t clang_type)
3831{
3832    if (clang_type)
3833    {
3834        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3835        const clang::Type *t = qual_type.getTypePtr();
3836        if (t)
3837        {
3838            const TagType *tag_type = dyn_cast<TagType>(t);
3839            if (tag_type)
3840            {
3841                TagDecl *tag_decl = tag_type->getDecl();
3842                if (tag_decl)
3843                {
3844                    tag_decl->startDefinition();
3845                    return true;
3846                }
3847            }
3848        }
3849    }
3850    return false;
3851}
3852
3853bool
3854ClangASTContext::CompleteTagDeclarationDefinition (clang_type_t clang_type)
3855{
3856    if (clang_type)
3857    {
3858        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
3859
3860        CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
3861
3862        if (cxx_record_decl)
3863        {
3864            cxx_record_decl->completeDefinition();
3865
3866            return true;
3867        }
3868
3869        const ObjCObjectType *objc_class_type = dyn_cast<ObjCObjectType>(qual_type);
3870
3871        if (objc_class_type)
3872        {
3873            ObjCInterfaceDecl *class_interface_decl = objc_class_type->getInterface();
3874
3875            class_interface_decl->setForwardDecl(false);
3876        }
3877
3878        const EnumType *enum_type = dyn_cast<EnumType>(qual_type.getTypePtr());
3879
3880        if (enum_type)
3881        {
3882            EnumDecl *enum_decl = enum_type->getDecl();
3883
3884            if (enum_decl)
3885            {
3886                /// TODO This really needs to be fixed.
3887
3888                unsigned NumPositiveBits = 1;
3889                unsigned NumNegativeBits = 0;
3890
3891                ASTContext *ast = getASTContext();
3892
3893                QualType promotion_qual_type;
3894                // If the enum integer type is less than an integer in bit width,
3895                // then we must promote it to an integer size.
3896                if (ast->getTypeSize(enum_decl->getIntegerType()) < ast->getTypeSize(ast->IntTy))
3897                {
3898                    if (enum_decl->getIntegerType()->isSignedIntegerType())
3899                        promotion_qual_type = ast->IntTy;
3900                    else
3901                        promotion_qual_type = ast->UnsignedIntTy;
3902                }
3903                else
3904                    promotion_qual_type = enum_decl->getIntegerType();
3905
3906                enum_decl->completeDefinition(enum_decl->getIntegerType(), promotion_qual_type, NumPositiveBits, NumNegativeBits);
3907                return true;
3908            }
3909        }
3910    }
3911    return false;
3912}
3913
3914
3915#pragma mark Enumeration Types
3916
3917clang_type_t
3918ClangASTContext::CreateEnumerationType
3919(
3920    const char *name,
3921    DeclContext *decl_ctx,
3922    const Declaration &decl,
3923    clang_type_t integer_qual_type
3924)
3925{
3926    // TODO: Do something intelligent with the Declaration object passed in
3927    // like maybe filling in the SourceLocation with it...
3928    ASTContext *ast = getASTContext();
3929    assert (ast != NULL);
3930
3931    // TODO: ask about these...
3932//    const bool IsScoped = false;
3933//    const bool IsFixed = false;
3934
3935    EnumDecl *enum_decl = EnumDecl::Create (*ast,
3936                                            decl_ctx,
3937                                            SourceLocation(),
3938                                            SourceLocation(),
3939                                            name && name[0] ? &ast->Idents.get(name) : NULL,
3940                                            NULL,
3941                                            false,  // IsScoped
3942                                            false,  // IsScopedUsingClassTag
3943                                            false); // IsFixed
3944
3945
3946    if (enum_decl)
3947    {
3948        // TODO: check if we should be setting the promotion type too?
3949        enum_decl->setIntegerType(QualType::getFromOpaquePtr (integer_qual_type));
3950
3951        enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
3952
3953        return ast->getTagDeclType(enum_decl).getAsOpaquePtr();
3954    }
3955    return NULL;
3956}
3957
3958clang_type_t
3959ClangASTContext::GetEnumerationIntegerType (clang_type_t enum_clang_type)
3960{
3961    QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3962
3963    const clang::Type *clang_type = enum_qual_type.getTypePtr();
3964    if (clang_type)
3965    {
3966        const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
3967        if (enum_type)
3968        {
3969            EnumDecl *enum_decl = enum_type->getDecl();
3970            if (enum_decl)
3971                return enum_decl->getIntegerType().getAsOpaquePtr();
3972        }
3973    }
3974    return NULL;
3975}
3976bool
3977ClangASTContext::AddEnumerationValueToEnumerationType
3978(
3979    clang_type_t enum_clang_type,
3980    clang_type_t enumerator_clang_type,
3981    const Declaration &decl,
3982    const char *name,
3983    int64_t enum_value,
3984    uint32_t enum_value_bit_size
3985)
3986{
3987    if (enum_clang_type && enumerator_clang_type && name)
3988    {
3989        // TODO: Do something intelligent with the Declaration object passed in
3990        // like maybe filling in the SourceLocation with it...
3991        ASTContext *ast = getASTContext();
3992        IdentifierTable *identifier_table = getIdentifierTable();
3993
3994        assert (ast != NULL);
3995        assert (identifier_table != NULL);
3996        QualType enum_qual_type (QualType::getFromOpaquePtr(enum_clang_type));
3997
3998        const clang::Type *clang_type = enum_qual_type.getTypePtr();
3999        if (clang_type)
4000        {
4001            const EnumType *enum_type = dyn_cast<EnumType>(clang_type);
4002
4003            if (enum_type)
4004            {
4005                llvm::APSInt enum_llvm_apsint(enum_value_bit_size, false);
4006                enum_llvm_apsint = enum_value;
4007                EnumConstantDecl *enumerator_decl =
4008                    EnumConstantDecl::Create (*ast,
4009                                              enum_type->getDecl(),
4010                                              SourceLocation(),
4011                                              name ? &identifier_table->get(name) : NULL,    // Identifier
4012                                              QualType::getFromOpaquePtr(enumerator_clang_type),
4013                                              NULL,
4014                                              enum_llvm_apsint);
4015
4016                if (enumerator_decl)
4017                {
4018                    enum_type->getDecl()->addDecl(enumerator_decl);
4019                    return true;
4020                }
4021            }
4022        }
4023    }
4024    return false;
4025}
4026
4027#pragma mark Pointers & References
4028
4029clang_type_t
4030ClangASTContext::CreatePointerType (clang_type_t clang_type)
4031{
4032    return CreatePointerType (getASTContext(), clang_type);
4033}
4034
4035clang_type_t
4036ClangASTContext::CreatePointerType (clang::ASTContext *ast, clang_type_t clang_type)
4037{
4038    if (ast && clang_type)
4039    {
4040        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4041
4042        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4043        switch (type_class)
4044        {
4045        case clang::Type::ObjCObject:
4046        case clang::Type::ObjCInterface:
4047            return ast->getObjCObjectPointerType(qual_type).getAsOpaquePtr();
4048
4049        default:
4050            return ast->getPointerType(qual_type).getAsOpaquePtr();
4051        }
4052    }
4053    return NULL;
4054}
4055
4056clang_type_t
4057ClangASTContext::CreateLValueReferenceType (clang::ASTContext *ast,
4058                                            clang_type_t clang_type)
4059{
4060    if (clang_type)
4061        return ast->getLValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
4062    return NULL;
4063}
4064
4065clang_type_t
4066ClangASTContext::CreateRValueReferenceType (clang::ASTContext *ast,
4067                                            clang_type_t clang_type)
4068{
4069    if (clang_type)
4070        return ast->getRValueReferenceType (QualType::getFromOpaquePtr(clang_type)).getAsOpaquePtr();
4071    return NULL;
4072}
4073
4074clang_type_t
4075ClangASTContext::CreateMemberPointerType (clang_type_t clang_pointee_type, clang_type_t clang_class_type)
4076{
4077    if (clang_pointee_type && clang_pointee_type)
4078        return getASTContext()->getMemberPointerType(QualType::getFromOpaquePtr(clang_pointee_type),
4079                                                     QualType::getFromOpaquePtr(clang_class_type).getTypePtr()).getAsOpaquePtr();
4080    return NULL;
4081}
4082
4083uint32_t
4084ClangASTContext::GetPointerBitSize ()
4085{
4086    ASTContext *ast = getASTContext();
4087    return ast->getTypeSize(ast->VoidPtrTy);
4088}
4089
4090bool
4091ClangASTContext::IsPossibleDynamicType (clang::ASTContext *ast, clang_type_t clang_type, clang_type_t *dynamic_pointee_type)
4092{
4093    QualType pointee_qual_type;
4094    if (clang_type)
4095    {
4096        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4097        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4098        bool success = false;
4099        switch (type_class)
4100        {
4101            case clang::Type::Builtin:
4102                if (cast<clang::BuiltinType>(qual_type)->getKind() == clang::BuiltinType::ObjCId)
4103                {
4104                    if (dynamic_pointee_type)
4105                        *dynamic_pointee_type = clang_type;
4106                    return true;
4107                }
4108                break;
4109
4110            case clang::Type::ObjCObjectPointer:
4111                if (dynamic_pointee_type)
4112                    *dynamic_pointee_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4113                return true;
4114
4115            case clang::Type::Pointer:
4116                pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType();
4117                success = true;
4118                break;
4119
4120            case clang::Type::LValueReference:
4121            case clang::Type::RValueReference:
4122                pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType();
4123                success = true;
4124                break;
4125
4126            case clang::Type::Typedef:
4127                return ClangASTContext::IsPossibleDynamicType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), dynamic_pointee_type);
4128
4129            default:
4130                break;
4131        }
4132
4133        if (success)
4134        {
4135            // Check to make sure what we are pointing too is a possible dynamic C++ type
4136            // We currently accept any "void *" (in case we have a class that has been
4137            // watered down to an opaque pointer) and virtual C++ classes.
4138            const clang::Type::TypeClass pointee_type_class = pointee_qual_type->getTypeClass();
4139            switch (pointee_type_class)
4140            {
4141                case clang::Type::Builtin:
4142                    switch (cast<clang::BuiltinType>(pointee_qual_type)->getKind())
4143                    {
4144                        case clang::BuiltinType::UnknownAny:
4145                        case clang::BuiltinType::Void:
4146                            if (dynamic_pointee_type)
4147                                *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
4148                            return true;
4149
4150                        case clang::BuiltinType::NullPtr:
4151                        case clang::BuiltinType::Bool:
4152                        case clang::BuiltinType::Char_U:
4153                        case clang::BuiltinType::UChar:
4154                        case clang::BuiltinType::WChar_U:
4155                        case clang::BuiltinType::Char16:
4156                        case clang::BuiltinType::Char32:
4157                        case clang::BuiltinType::UShort:
4158                        case clang::BuiltinType::UInt:
4159                        case clang::BuiltinType::ULong:
4160                        case clang::BuiltinType::ULongLong:
4161                        case clang::BuiltinType::UInt128:
4162                        case clang::BuiltinType::Char_S:
4163                        case clang::BuiltinType::SChar:
4164                        case clang::BuiltinType::WChar_S:
4165                        case clang::BuiltinType::Short:
4166                        case clang::BuiltinType::Int:
4167                        case clang::BuiltinType::Long:
4168                        case clang::BuiltinType::LongLong:
4169                        case clang::BuiltinType::Int128:
4170                        case clang::BuiltinType::Float:
4171                        case clang::BuiltinType::Double:
4172                        case clang::BuiltinType::LongDouble:
4173                        case clang::BuiltinType::Dependent:
4174                        case clang::BuiltinType::Overload:
4175                        case clang::BuiltinType::ObjCId:
4176                        case clang::BuiltinType::ObjCClass:
4177                        case clang::BuiltinType::ObjCSel:
4178                        case clang::BuiltinType::BoundMember:
4179                            break;
4180                    }
4181                    break;
4182
4183                case clang::Type::Record:
4184                    {
4185                        CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
4186                        if (cxx_record_decl)
4187                        {
4188                            if (GetCompleteQualType (ast, pointee_qual_type))
4189                            {
4190                                success = cxx_record_decl->isDynamicClass();
4191                            }
4192                            else
4193                            {
4194                                // We failed to get the complete type, so we have to
4195                                // treat this as a void * which we might possibly be
4196                                // able to complete
4197                                success = true;
4198                            }
4199                            if (success)
4200                            {
4201                                if (dynamic_pointee_type)
4202                                    *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
4203                                return true;
4204                            }
4205                        }
4206                    }
4207                    break;
4208
4209                case clang::Type::ObjCObject:
4210                case clang::Type::ObjCInterface:
4211                    {
4212                        const clang::ObjCObjectType *objc_class_type = pointee_qual_type->getAsObjCQualifiedInterfaceType();
4213                        if (objc_class_type)
4214                        {
4215                            GetCompleteQualType (ast, pointee_qual_type);
4216                            if (dynamic_pointee_type)
4217                                *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
4218                            return true;
4219                        }
4220                    }
4221                    break;
4222
4223                default:
4224                    break;
4225            }
4226        }
4227    }
4228    if (dynamic_pointee_type)
4229        *dynamic_pointee_type = NULL;
4230    return false;
4231}
4232
4233
4234bool
4235ClangASTContext::IsPossibleCPlusPlusDynamicType (clang::ASTContext *ast, clang_type_t clang_type, clang_type_t *dynamic_pointee_type)
4236{
4237    QualType pointee_qual_type;
4238    if (clang_type)
4239    {
4240        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4241        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4242        bool success = false;
4243        switch (type_class)
4244        {
4245            case clang::Type::Pointer:
4246                pointee_qual_type = cast<PointerType>(qual_type)->getPointeeType();
4247                success = true;
4248                break;
4249
4250            case clang::Type::LValueReference:
4251            case clang::Type::RValueReference:
4252                pointee_qual_type = cast<ReferenceType>(qual_type)->getPointeeType();
4253                success = true;
4254                break;
4255
4256            case clang::Type::Typedef:
4257                return ClangASTContext::IsPossibleCPlusPlusDynamicType (ast, cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), dynamic_pointee_type);
4258
4259            default:
4260                break;
4261        }
4262
4263        if (success)
4264        {
4265            // Check to make sure what we are pointing too is a possible dynamic C++ type
4266            // We currently accept any "void *" (in case we have a class that has been
4267            // watered down to an opaque pointer) and virtual C++ classes.
4268            const clang::Type::TypeClass pointee_type_class = pointee_qual_type->getTypeClass();
4269            switch (pointee_type_class)
4270            {
4271            case clang::Type::Builtin:
4272                switch (cast<clang::BuiltinType>(pointee_qual_type)->getKind())
4273                {
4274                    case clang::BuiltinType::UnknownAny:
4275                    case clang::BuiltinType::Void:
4276                        if (dynamic_pointee_type)
4277                            *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
4278                        return true;
4279
4280                    case clang::BuiltinType::NullPtr:
4281                    case clang::BuiltinType::Bool:
4282                    case clang::BuiltinType::Char_U:
4283                    case clang::BuiltinType::UChar:
4284                    case clang::BuiltinType::WChar_U:
4285                    case clang::BuiltinType::Char16:
4286                    case clang::BuiltinType::Char32:
4287                    case clang::BuiltinType::UShort:
4288                    case clang::BuiltinType::UInt:
4289                    case clang::BuiltinType::ULong:
4290                    case clang::BuiltinType::ULongLong:
4291                    case clang::BuiltinType::UInt128:
4292                    case clang::BuiltinType::Char_S:
4293                    case clang::BuiltinType::SChar:
4294                    case clang::BuiltinType::WChar_S:
4295                    case clang::BuiltinType::Short:
4296                    case clang::BuiltinType::Int:
4297                    case clang::BuiltinType::Long:
4298                    case clang::BuiltinType::LongLong:
4299                    case clang::BuiltinType::Int128:
4300                    case clang::BuiltinType::Float:
4301                    case clang::BuiltinType::Double:
4302                    case clang::BuiltinType::LongDouble:
4303                    case clang::BuiltinType::Dependent:
4304                    case clang::BuiltinType::Overload:
4305                    case clang::BuiltinType::ObjCId:
4306                    case clang::BuiltinType::ObjCClass:
4307                    case clang::BuiltinType::ObjCSel:
4308                    case clang::BuiltinType::BoundMember:
4309                        break;
4310                }
4311                break;
4312            case clang::Type::Record:
4313                {
4314                    CXXRecordDecl *cxx_record_decl = pointee_qual_type->getAsCXXRecordDecl();
4315                    if (cxx_record_decl)
4316                    {
4317                        if (GetCompleteQualType (ast, pointee_qual_type))
4318                        {
4319                            success = cxx_record_decl->isDynamicClass();
4320                        }
4321                        else
4322                        {
4323                            // We failed to get the complete type, so we have to
4324                            // treat this as a void * which we might possibly be
4325                            // able to complete
4326                            success = true;
4327                        }
4328                        if (success)
4329                        {
4330                            if (dynamic_pointee_type)
4331                                *dynamic_pointee_type = pointee_qual_type.getAsOpaquePtr();
4332                            return true;
4333                        }
4334                    }
4335                }
4336                break;
4337
4338            default:
4339                break;
4340            }
4341        }
4342    }
4343    if (dynamic_pointee_type)
4344        *dynamic_pointee_type = NULL;
4345    return false;
4346}
4347
4348
4349bool
4350ClangASTContext::IsPointerOrReferenceType (clang_type_t clang_type, clang_type_t*target_type)
4351{
4352    if (clang_type == NULL)
4353        return false;
4354
4355    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4356    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4357    switch (type_class)
4358    {
4359    case clang::Type::Builtin:
4360        switch (cast<clang::BuiltinType>(qual_type)->getKind())
4361        {
4362        default:
4363            break;
4364        case clang::BuiltinType::ObjCId:
4365        case clang::BuiltinType::ObjCClass:
4366            return true;
4367        }
4368        return false;
4369    case clang::Type::ObjCObjectPointer:
4370        if (target_type)
4371            *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4372        return true;
4373    case clang::Type::BlockPointer:
4374        if (target_type)
4375            *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4376        return true;
4377    case clang::Type::Pointer:
4378        if (target_type)
4379            *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4380        return true;
4381    case clang::Type::MemberPointer:
4382        if (target_type)
4383            *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4384        return true;
4385    case clang::Type::LValueReference:
4386        if (target_type)
4387            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
4388        return true;
4389    case clang::Type::RValueReference:
4390        if (target_type)
4391            *target_type = cast<LValueReferenceType>(qual_type)->desugar().getAsOpaquePtr();
4392        return true;
4393    case clang::Type::Typedef:
4394        return ClangASTContext::IsPointerOrReferenceType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
4395    default:
4396        break;
4397    }
4398    return false;
4399}
4400
4401bool
4402ClangASTContext::IsIntegerType (clang_type_t clang_type, bool &is_signed)
4403{
4404    if (!clang_type)
4405        return false;
4406
4407    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4408    const BuiltinType *builtin_type = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal());
4409
4410    if (builtin_type)
4411    {
4412        if (builtin_type->isInteger())
4413            is_signed = builtin_type->isSignedInteger();
4414
4415        return true;
4416    }
4417
4418    return false;
4419}
4420
4421bool
4422ClangASTContext::IsPointerType (clang_type_t clang_type, clang_type_t *target_type)
4423{
4424    if (target_type)
4425        *target_type = NULL;
4426
4427    if (clang_type)
4428    {
4429        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4430        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4431        switch (type_class)
4432        {
4433        case clang::Type::Builtin:
4434            switch (cast<clang::BuiltinType>(qual_type)->getKind())
4435            {
4436            default:
4437                break;
4438            case clang::BuiltinType::ObjCId:
4439            case clang::BuiltinType::ObjCClass:
4440                return true;
4441            }
4442            return false;
4443        case clang::Type::ObjCObjectPointer:
4444            if (target_type)
4445                *target_type = cast<ObjCObjectPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4446            return true;
4447        case clang::Type::BlockPointer:
4448            if (target_type)
4449                *target_type = cast<BlockPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4450            return true;
4451        case clang::Type::Pointer:
4452            if (target_type)
4453                *target_type = cast<PointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4454            return true;
4455        case clang::Type::MemberPointer:
4456            if (target_type)
4457                *target_type = cast<MemberPointerType>(qual_type)->getPointeeType().getAsOpaquePtr();
4458            return true;
4459        case clang::Type::Typedef:
4460            return ClangASTContext::IsPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(), target_type);
4461        default:
4462            break;
4463        }
4464    }
4465    return false;
4466}
4467
4468bool
4469ClangASTContext::IsFloatingPointType (clang_type_t clang_type, uint32_t &count, bool &is_complex)
4470{
4471    if (clang_type)
4472    {
4473        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4474
4475        if (const BuiltinType *BT = dyn_cast<BuiltinType>(qual_type->getCanonicalTypeInternal()))
4476        {
4477            clang::BuiltinType::Kind kind = BT->getKind();
4478            if (kind >= BuiltinType::Float && kind <= BuiltinType::LongDouble)
4479            {
4480                count = 1;
4481                is_complex = false;
4482                return true;
4483            }
4484        }
4485        else if (const ComplexType *CT = dyn_cast<ComplexType>(qual_type->getCanonicalTypeInternal()))
4486        {
4487            if (IsFloatingPointType(CT->getElementType().getAsOpaquePtr(), count, is_complex))
4488            {
4489                count = 2;
4490                is_complex = true;
4491                return true;
4492            }
4493        }
4494        else if (const VectorType *VT = dyn_cast<VectorType>(qual_type->getCanonicalTypeInternal()))
4495        {
4496            if (IsFloatingPointType(VT->getElementType().getAsOpaquePtr(), count, is_complex))
4497            {
4498                count = VT->getNumElements();
4499                is_complex = false;
4500                return true;
4501            }
4502        }
4503    }
4504    return false;
4505}
4506
4507bool
4508ClangASTContext::IsScalarType (lldb::clang_type_t clang_type)
4509{
4510    bool is_signed;
4511    if (ClangASTContext::IsIntegerType(clang_type, is_signed))
4512        return true;
4513
4514    uint32_t count;
4515    bool is_complex;
4516    return ClangASTContext::IsFloatingPointType(clang_type, count, is_complex) && !is_complex;
4517}
4518
4519bool
4520ClangASTContext::IsPointerToScalarType (lldb::clang_type_t clang_type)
4521{
4522    if (!IsPointerType(clang_type))
4523        return false;
4524
4525    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4526    lldb::clang_type_t pointee_type = qual_type.getTypePtr()->getPointeeType().getAsOpaquePtr();
4527    return IsScalarType(pointee_type);
4528}
4529
4530bool
4531ClangASTContext::IsArrayOfScalarType (lldb::clang_type_t clang_type)
4532{
4533    if (!IsArrayType(clang_type))
4534        return false;
4535
4536    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4537    lldb::clang_type_t item_type = cast<ArrayType>(qual_type.getTypePtr())->getElementType().getAsOpaquePtr();
4538    return IsScalarType(item_type);
4539}
4540
4541
4542bool
4543ClangASTContext::GetCXXClassName (clang_type_t clang_type, std::string &class_name)
4544{
4545    if (clang_type)
4546    {
4547        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4548
4549        CXXRecordDecl *cxx_record_decl = qual_type->getAsCXXRecordDecl();
4550        if (cxx_record_decl)
4551        {
4552            class_name.assign (cxx_record_decl->getIdentifier()->getNameStart());
4553            return true;
4554        }
4555    }
4556    class_name.clear();
4557    return false;
4558}
4559
4560
4561bool
4562ClangASTContext::IsCXXClassType (clang_type_t clang_type)
4563{
4564    if (clang_type)
4565    {
4566        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4567        if (qual_type->getAsCXXRecordDecl() != NULL)
4568            return true;
4569    }
4570    return false;
4571}
4572
4573bool
4574ClangASTContext::IsObjCClassType (clang_type_t clang_type)
4575{
4576    if (clang_type)
4577    {
4578        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4579        if (qual_type->isObjCObjectOrInterfaceType())
4580            return true;
4581    }
4582    return false;
4583}
4584
4585
4586bool
4587ClangASTContext::IsCharType (clang_type_t clang_type)
4588{
4589    if (clang_type)
4590        return QualType::getFromOpaquePtr(clang_type)->isCharType();
4591    return false;
4592}
4593
4594bool
4595ClangASTContext::IsCStringType (clang_type_t clang_type, uint32_t &length)
4596{
4597    clang_type_t pointee_or_element_clang_type = NULL;
4598    Flags type_flags (ClangASTContext::GetTypeInfo (clang_type, NULL, &pointee_or_element_clang_type));
4599
4600    if (pointee_or_element_clang_type == NULL)
4601        return false;
4602
4603    if (type_flags.AnySet (eTypeIsArray | eTypeIsPointer))
4604    {
4605        QualType pointee_or_element_qual_type (QualType::getFromOpaquePtr (pointee_or_element_clang_type));
4606
4607        if (pointee_or_element_qual_type.getUnqualifiedType()->isCharType())
4608        {
4609            QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4610            if (type_flags.Test (eTypeIsArray))
4611            {
4612                // We know the size of the array and it could be a C string
4613                // since it is an array of characters
4614                length = cast<ConstantArrayType>(qual_type.getTypePtr())->getSize().getLimitedValue();
4615                return true;
4616            }
4617            else
4618            {
4619                length = 0;
4620                return true;
4621            }
4622
4623        }
4624    }
4625    return false;
4626}
4627
4628bool
4629ClangASTContext::IsFunctionPointerType (clang_type_t clang_type)
4630{
4631    if (clang_type)
4632    {
4633        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4634
4635        if (qual_type->isFunctionPointerType())
4636            return true;
4637
4638        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4639        switch (type_class)
4640        {
4641        default:
4642            break;
4643        case clang::Type::Typedef:
4644            return ClangASTContext::IsFunctionPointerType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
4645
4646        case clang::Type::LValueReference:
4647        case clang::Type::RValueReference:
4648            {
4649                const ReferenceType *reference_type = cast<ReferenceType>(qual_type.getTypePtr());
4650                if (reference_type)
4651                    return ClangASTContext::IsFunctionPointerType (reference_type->getPointeeType().getAsOpaquePtr());
4652            }
4653            break;
4654        }
4655    }
4656    return false;
4657}
4658
4659size_t
4660ClangASTContext::GetArraySize (clang_type_t clang_type)
4661{
4662    if (clang_type)
4663    {
4664        QualType qual_type(QualType::getFromOpaquePtr(clang_type));
4665        const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4666        switch (type_class)
4667        {
4668        case clang::Type::ConstantArray:
4669            {
4670                const ConstantArrayType *array = cast<ConstantArrayType>(QualType::getFromOpaquePtr(clang_type).getTypePtr());
4671                if (array)
4672                    return array->getSize().getLimitedValue();
4673            }
4674            break;
4675
4676        case clang::Type::Typedef:
4677            return ClangASTContext::GetArraySize(cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr());
4678            break;
4679
4680        default:
4681            break;
4682        }
4683    }
4684    return 0;
4685}
4686
4687bool
4688ClangASTContext::IsArrayType (clang_type_t clang_type, clang_type_t*member_type, uint64_t *size)
4689{
4690    if (!clang_type)
4691        return false;
4692
4693    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4694
4695    const clang::Type::TypeClass type_class = qual_type->getTypeClass();
4696    switch (type_class)
4697    {
4698    default:
4699        break;
4700
4701    case clang::Type::ConstantArray:
4702        if (member_type)
4703            *member_type = cast<ConstantArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4704        if (size)
4705            *size = cast<ConstantArrayType>(qual_type)->getSize().getLimitedValue(ULLONG_MAX);
4706        return true;
4707
4708    case clang::Type::IncompleteArray:
4709        if (member_type)
4710            *member_type = cast<IncompleteArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4711        if (size)
4712            *size = 0;
4713        return true;
4714
4715    case clang::Type::VariableArray:
4716        if (member_type)
4717            *member_type = cast<VariableArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4718        if (size)
4719            *size = 0;
4720        return true;
4721
4722    case clang::Type::DependentSizedArray:
4723        if (member_type)
4724            *member_type = cast<DependentSizedArrayType>(qual_type)->getElementType().getAsOpaquePtr();
4725        if (size)
4726            *size = 0;
4727        return true;
4728
4729    case clang::Type::Typedef:
4730        return ClangASTContext::IsArrayType (cast<TypedefType>(qual_type)->getDecl()->getUnderlyingType().getAsOpaquePtr(),
4731                                             member_type,
4732                                             size);
4733    }
4734    return false;
4735}
4736
4737
4738#pragma mark Typedefs
4739
4740clang_type_t
4741ClangASTContext::CreateTypedefType (const char *name, clang_type_t clang_type, DeclContext *decl_ctx)
4742{
4743    if (clang_type)
4744    {
4745        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4746        ASTContext *ast = getASTContext();
4747        IdentifierTable *identifier_table = getIdentifierTable();
4748        assert (ast != NULL);
4749        assert (identifier_table != NULL);
4750        if (decl_ctx == NULL)
4751            decl_ctx = ast->getTranslationUnitDecl();
4752        TypedefDecl *decl = TypedefDecl::Create (*ast,
4753                                                 decl_ctx,
4754                                                 SourceLocation(),
4755                                                 SourceLocation(),
4756                                                 name ? &identifier_table->get(name) : NULL, // Identifier
4757                                                 ast->CreateTypeSourceInfo(qual_type));
4758
4759        decl->setAccess(AS_public); // TODO respect proper access specifier
4760
4761        // Get a uniqued QualType for the typedef decl type
4762        return ast->getTypedefType (decl).getAsOpaquePtr();
4763    }
4764    return NULL;
4765}
4766
4767// Disable this for now since I can't seem to get a nicely formatted float
4768// out of the APFloat class without just getting the float, double or quad
4769// and then using a formatted print on it which defeats the purpose. We ideally
4770// would like to get perfect string values for any kind of float semantics
4771// so we can support remote targets. The code below also requires a patch to
4772// llvm::APInt.
4773//bool
4774//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)
4775//{
4776//  uint32_t count = 0;
4777//  bool is_complex = false;
4778//  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4779//  {
4780//      unsigned num_bytes_per_float = byte_size / count;
4781//      unsigned num_bits_per_float = num_bytes_per_float * 8;
4782//
4783//      float_str.clear();
4784//      uint32_t i;
4785//      for (i=0; i<count; i++)
4786//      {
4787//          APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
4788//          bool is_ieee = false;
4789//          APFloat ap_float(ap_int, is_ieee);
4790//          char s[1024];
4791//          unsigned int hex_digits = 0;
4792//          bool upper_case = false;
4793//
4794//          if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
4795//          {
4796//              if (i > 0)
4797//                  float_str.append(", ");
4798//              float_str.append(s);
4799//              if (i == 1 && is_complex)
4800//                  float_str.append(1, 'i');
4801//          }
4802//      }
4803//      return !float_str.empty();
4804//  }
4805//  return false;
4806//}
4807
4808size_t
4809ClangASTContext::ConvertStringToFloatValue (ASTContext *ast, clang_type_t clang_type, const char *s, uint8_t *dst, size_t dst_size)
4810{
4811    if (clang_type)
4812    {
4813        QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4814        uint32_t count = 0;
4815        bool is_complex = false;
4816        if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
4817        {
4818            // TODO: handle complex and vector types
4819            if (count != 1)
4820                return false;
4821
4822            StringRef s_sref(s);
4823            APFloat ap_float(ast->getFloatTypeSemantics(qual_type), s_sref);
4824
4825            const uint64_t bit_size = ast->getTypeSize (qual_type);
4826            const uint64_t byte_size = bit_size / 8;
4827            if (dst_size >= byte_size)
4828            {
4829                if (bit_size == sizeof(float)*8)
4830                {
4831                    float float32 = ap_float.convertToFloat();
4832                    ::memcpy (dst, &float32, byte_size);
4833                    return byte_size;
4834                }
4835                else if (bit_size >= 64)
4836                {
4837                    llvm::APInt ap_int(ap_float.bitcastToAPInt());
4838                    ::memcpy (dst, ap_int.getRawData(), byte_size);
4839                    return byte_size;
4840                }
4841            }
4842        }
4843    }
4844    return 0;
4845}
4846
4847unsigned
4848ClangASTContext::GetTypeQualifiers(clang_type_t clang_type)
4849{
4850    assert (clang_type);
4851
4852    QualType qual_type (QualType::getFromOpaquePtr(clang_type));
4853
4854    return qual_type.getQualifiers().getCVRQualifiers();
4855}
4856
4857bool
4858ClangASTContext::GetCompleteType (clang::ASTContext *ast, lldb::clang_type_t clang_type)
4859{
4860    if (clang_type == NULL)
4861        return false;
4862
4863    return GetCompleteQualType (ast, clang::QualType::getFromOpaquePtr(clang_type));
4864}
4865
4866
4867bool
4868ClangASTContext::GetCompleteType (clang_type_t clang_type)
4869{
4870    return ClangASTContext::GetCompleteType (getASTContext(), clang_type);
4871}
4872
4873bool
4874ClangASTContext::GetCompleteDecl (clang::ASTContext *ast,
4875                                  clang::Decl *decl)
4876{
4877    if (!decl)
4878        return false;
4879
4880    ExternalASTSource *ast_source = ast->getExternalSource();
4881
4882    if (!ast_source)
4883        return false;
4884
4885    if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
4886    {
4887        if (tag_decl->getDefinition())
4888            return true;
4889
4890        if (!tag_decl->hasExternalLexicalStorage())
4891            return false;
4892
4893        ast_source->CompleteType(tag_decl);
4894
4895        return !tag_decl->getTypeForDecl()->isIncompleteType();
4896    }
4897    else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
4898    {
4899        if (!objc_interface_decl->isForwardDecl())
4900            return true;
4901
4902        if (!objc_interface_decl->hasExternalLexicalStorage())
4903            return false;
4904
4905        ast_source->CompleteType(objc_interface_decl);
4906
4907        return !objc_interface_decl->isForwardDecl();
4908    }
4909    else
4910    {
4911        return false;
4912    }
4913}
4914
4915clang::DeclContext *
4916ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl)
4917{
4918    return clang::dyn_cast<clang::DeclContext>(cxx_method_decl);
4919}
4920
4921clang::DeclContext *
4922ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl)
4923{
4924    return clang::dyn_cast<clang::DeclContext>(objc_method_decl);
4925}
4926
4927