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