ClangASTContext.cpp revision 269024 
1//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
10#include "lldb/Symbol/ClangASTContext.h"
11
12// C Includes
13// C++ Includes
14#include <string>
15
16// Other libraries and framework includes
17
18// Clang headers like to use NDEBUG inside of them to enable/disable debug
19// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing
20// or another. This is bad because it means that if clang was built in release
21// mode, it assumes that you are building in release mode which is not always
22// the case. You can end up with functions that are defined as empty in header
23// files when NDEBUG is not defined, and this can cause link errors with the
24// clang .a files that you have since you might be missing functions in the .a
25// file. So we have to define NDEBUG when including clang headers to avoid any
26// mismatches. This is covered by rdar://problem/8691220
27
28#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF)
29#define LLDB_DEFINED_NDEBUG_FOR_CLANG
30#define NDEBUG
31// Need to include assert.h so it is as clang would expect it to be (disabled)
32#include <assert.h>
33#endif
34
35#include "clang/AST/ASTContext.h"
36#include "clang/AST/ASTImporter.h"
37#include "clang/AST/Attr.h"
38#include "clang/AST/CXXInheritance.h"
39#include "clang/AST/DeclObjC.h"
40#include "clang/AST/DeclTemplate.h"
41#include "clang/AST/RecordLayout.h"
42#include "clang/AST/Type.h"
43#include "clang/Basic/Builtins.h"
44#include "clang/Basic/Diagnostic.h"
45#include "clang/Basic/FileManager.h"
46#include "clang/Basic/FileSystemOptions.h"
47#include "clang/Basic/SourceManager.h"
48#include "clang/Basic/TargetInfo.h"
49#include "clang/Basic/TargetOptions.h"
50#include "clang/Frontend/FrontendOptions.h"
51#include "clang/Frontend/LangStandard.h"
52
53#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG
54#undef NDEBUG
55#undef LLDB_DEFINED_NDEBUG_FOR_CLANG
56// Need to re-include assert.h so it is as _we_ would expect it to be (enabled)
57#include <assert.h>
58#endif
59
60#include "lldb/Core/ArchSpec.h"
61#include "lldb/Core/dwarf.h"
62#include "lldb/Core/Flags.h"
63#include "lldb/Core/Log.h"
64#include "lldb/Core/RegularExpression.h"
65#include "lldb/Core/UniqueCStringMap.h"
66#include "lldb/Expression/ASTDumper.h"
67#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
68#include "lldb/Symbol/VerifyDecl.h"
69#include "lldb/Target/ExecutionContext.h"
70#include "lldb/Target/Process.h"
71#include "lldb/Target/ObjCLanguageRuntime.h"
72
73#include <stdio.h>
74
75#include <mutex>
76
77using namespace lldb;
78using namespace lldb_private;
79using namespace llvm;
80using namespace clang;
81
82clang::AccessSpecifier
83ClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access)
84{
85    switch (access)
86    {
87    default:               break;
88    case eAccessNone:      return AS_none;
89    case eAccessPublic:    return AS_public;
90    case eAccessPrivate:   return AS_private;
91    case eAccessProtected: return AS_protected;
92    }
93    return AS_none;
94}
95
96
97static void
98ParseLangArgs
99(
100    LangOptions &Opts,
101    InputKind IK
102)
103{
104    // FIXME: Cleanup per-file based stuff.
105
106    // Set some properties which depend soley on the input kind; it would be nice
107    // to move these to the language standard, and have the driver resolve the
108    // input kind + language standard.
109    if (IK == IK_Asm) {
110        Opts.AsmPreprocessor = 1;
111    } else if (IK == IK_ObjC ||
112               IK == IK_ObjCXX ||
113               IK == IK_PreprocessedObjC ||
114               IK == IK_PreprocessedObjCXX) {
115        Opts.ObjC1 = Opts.ObjC2 = 1;
116    }
117
118    LangStandard::Kind LangStd = LangStandard::lang_unspecified;
119
120    if (LangStd == LangStandard::lang_unspecified) {
121        // Based on the base language, pick one.
122        switch (IK) {
123            case IK_None:
124            case IK_AST:
125            case IK_LLVM_IR:
126                assert (!"Invalid input kind!");
127            case IK_OpenCL:
128                LangStd = LangStandard::lang_opencl;
129                break;
130            case IK_CUDA:
131                LangStd = LangStandard::lang_cuda;
132                break;
133            case IK_Asm:
134            case IK_C:
135            case IK_PreprocessedC:
136            case IK_ObjC:
137            case IK_PreprocessedObjC:
138                LangStd = LangStandard::lang_gnu99;
139                break;
140            case IK_CXX:
141            case IK_PreprocessedCXX:
142            case IK_ObjCXX:
143            case IK_PreprocessedObjCXX:
144                LangStd = LangStandard::lang_gnucxx98;
145                break;
146        }
147    }
148
149    const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd);
150    Opts.LineComment = Std.hasLineComments();
151    Opts.C99 = Std.isC99();
152    Opts.CPlusPlus = Std.isCPlusPlus();
153    Opts.CPlusPlus11 = Std.isCPlusPlus11();
154    Opts.Digraphs = Std.hasDigraphs();
155    Opts.GNUMode = Std.isGNUMode();
156    Opts.GNUInline = !Std.isC99();
157    Opts.HexFloats = Std.hasHexFloats();
158    Opts.ImplicitInt = Std.hasImplicitInt();
159
160    Opts.WChar = true;
161
162    // OpenCL has some additional defaults.
163    if (LangStd == LangStandard::lang_opencl) {
164        Opts.OpenCL = 1;
165        Opts.AltiVec = 1;
166        Opts.CXXOperatorNames = 1;
167        Opts.LaxVectorConversions = 1;
168    }
169
170    // OpenCL and C++ both have bool, true, false keywords.
171    Opts.Bool = Opts.OpenCL || Opts.CPlusPlus;
172
173//    if (Opts.CPlusPlus)
174//        Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names);
175//
176//    if (Args.hasArg(OPT_fobjc_gc_only))
177//        Opts.setGCMode(LangOptions::GCOnly);
178//    else if (Args.hasArg(OPT_fobjc_gc))
179//        Opts.setGCMode(LangOptions::HybridGC);
180//
181//    if (Args.hasArg(OPT_print_ivar_layout))
182//        Opts.ObjCGCBitmapPrint = 1;
183//
184//    if (Args.hasArg(OPT_faltivec))
185//        Opts.AltiVec = 1;
186//
187//    if (Args.hasArg(OPT_pthread))
188//        Opts.POSIXThreads = 1;
189//
190//    llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility,
191//                                          "default");
192//    if (Vis == "default")
193        Opts.setValueVisibilityMode(DefaultVisibility);
194//    else if (Vis == "hidden")
195//        Opts.setVisibilityMode(LangOptions::Hidden);
196//    else if (Vis == "protected")
197//        Opts.setVisibilityMode(LangOptions::Protected);
198//    else
199//        Diags.Report(diag::err_drv_invalid_value)
200//        << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis;
201
202//    Opts.OverflowChecking = Args.hasArg(OPT_ftrapv);
203
204    // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs
205    // is specified, or -std is set to a conforming mode.
206    Opts.Trigraphs = !Opts.GNUMode;
207//    if (Args.hasArg(OPT_trigraphs))
208//        Opts.Trigraphs = 1;
209//
210//    Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers,
211//                                     OPT_fno_dollars_in_identifiers,
212//                                     !Opts.AsmPreprocessor);
213//    Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings);
214//    Opts.Microsoft = Args.hasArg(OPT_fms_extensions);
215//    Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings);
216//    if (Args.hasArg(OPT_fno_lax_vector_conversions))
217//        Opts.LaxVectorConversions = 0;
218//    Opts.Exceptions = Args.hasArg(OPT_fexceptions);
219//    Opts.RTTI = !Args.hasArg(OPT_fno_rtti);
220//    Opts.Blocks = Args.hasArg(OPT_fblocks);
221//    Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char);
222//    Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar);
223//    Opts.Freestanding = Args.hasArg(OPT_ffreestanding);
224//    Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding;
225//    Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new);
226//    Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions);
227//    Opts.AccessControl = Args.hasArg(OPT_faccess_control);
228//    Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors);
229//    Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno);
230//    Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99,
231//                                                 Diags);
232//    Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime);
233//    Opts.ObjCConstantStringClass = getLastArgValue(Args,
234//                                                   OPT_fconstant_string_class);
235//    Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi);
236//    Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior);
237//    Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls);
238//    Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags);
239//    Opts.Static = Args.hasArg(OPT_static_define);
240    Opts.OptimizeSize = 0;
241
242    // FIXME: Eliminate this dependency.
243//    unsigned Opt =
244//    Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags);
245//    Opts.Optimize = Opt != 0;
246    unsigned Opt = 0;
247
248    // This is the __NO_INLINE__ define, which just depends on things like the
249    // optimization level and -fno-inline, not actually whether the backend has
250    // inlining enabled.
251    //
252    // FIXME: This is affected by other options (-fno-inline).
253    Opts.NoInlineDefine = !Opt;
254
255//    unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags);
256//    switch (SSP) {
257//        default:
258//            Diags.Report(diag::err_drv_invalid_value)
259//            << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP;
260//            break;
261//        case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break;
262//        case 1: Opts.setStackProtectorMode(LangOptions::SSPOn);  break;
263//        case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break;
264//    }
265}
266
267
268ClangASTContext::ClangASTContext (const char *target_triple) :
269    m_target_triple(),
270    m_ast_ap(),
271    m_language_options_ap(),
272    m_source_manager_ap(),
273    m_diagnostics_engine_ap(),
274    m_target_options_rp(),
275    m_target_info_ap(),
276    m_identifier_table_ap(),
277    m_selector_table_ap(),
278    m_builtins_ap(),
279    m_callback_tag_decl (NULL),
280    m_callback_objc_decl (NULL),
281    m_callback_baton (NULL),
282    m_pointer_byte_size (0)
283
284{
285    if (target_triple && target_triple[0])
286        SetTargetTriple (target_triple);
287}
288
289//----------------------------------------------------------------------
290// Destructor
291//----------------------------------------------------------------------
292ClangASTContext::~ClangASTContext()
293{
294    m_builtins_ap.reset();
295    m_selector_table_ap.reset();
296    m_identifier_table_ap.reset();
297    m_target_info_ap.reset();
298    m_target_options_rp.reset();
299    m_diagnostics_engine_ap.reset();
300    m_source_manager_ap.reset();
301    m_language_options_ap.reset();
302    m_ast_ap.reset();
303}
304
305
306void
307ClangASTContext::Clear()
308{
309    m_ast_ap.reset();
310    m_language_options_ap.reset();
311    m_source_manager_ap.reset();
312    m_diagnostics_engine_ap.reset();
313    m_target_options_rp.reset();
314    m_target_info_ap.reset();
315    m_identifier_table_ap.reset();
316    m_selector_table_ap.reset();
317    m_builtins_ap.reset();
318    m_pointer_byte_size = 0;
319}
320
321const char *
322ClangASTContext::GetTargetTriple ()
323{
324    return m_target_triple.c_str();
325}
326
327void
328ClangASTContext::SetTargetTriple (const char *target_triple)
329{
330    Clear();
331    m_target_triple.assign(target_triple);
332}
333
334void
335ClangASTContext::SetArchitecture (const ArchSpec &arch)
336{
337    SetTargetTriple(arch.GetTriple().str().c_str());
338}
339
340bool
341ClangASTContext::HasExternalSource ()
342{
343    ASTContext *ast = getASTContext();
344    if (ast)
345        return ast->getExternalSource () != NULL;
346    return false;
347}
348
349void
350ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap)
351{
352    ASTContext *ast = getASTContext();
353    if (ast)
354    {
355        ast->setExternalSource (ast_source_ap);
356        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true);
357        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true);
358    }
359}
360
361void
362ClangASTContext::RemoveExternalSource ()
363{
364    ASTContext *ast = getASTContext();
365
366    if (ast)
367    {
368        llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap;
369        ast->setExternalSource (empty_ast_source_ap);
370        ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false);
371        //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false);
372    }
373}
374
375
376
377ASTContext *
378ClangASTContext::getASTContext()
379{
380    if (m_ast_ap.get() == NULL)
381    {
382        m_ast_ap.reset(new ASTContext (*getLanguageOptions(),
383                                       *getSourceManager(),
384                                       getTargetInfo(),
385                                       *getIdentifierTable(),
386                                       *getSelectorTable(),
387                                       *getBuiltinContext(),
388                                       0));
389
390        if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton)
391        {
392            m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage();
393            //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage();
394        }
395
396        m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false);
397    }
398    return m_ast_ap.get();
399}
400
401Builtin::Context *
402ClangASTContext::getBuiltinContext()
403{
404    if (m_builtins_ap.get() == NULL)
405        m_builtins_ap.reset (new Builtin::Context());
406    return m_builtins_ap.get();
407}
408
409IdentifierTable *
410ClangASTContext::getIdentifierTable()
411{
412    if (m_identifier_table_ap.get() == NULL)
413        m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL));
414    return m_identifier_table_ap.get();
415}
416
417LangOptions *
418ClangASTContext::getLanguageOptions()
419{
420    if (m_language_options_ap.get() == NULL)
421    {
422        m_language_options_ap.reset(new LangOptions());
423        ParseLangArgs(*m_language_options_ap, IK_ObjCXX);
424//        InitializeLangOptions(*m_language_options_ap, IK_ObjCXX);
425    }
426    return m_language_options_ap.get();
427}
428
429SelectorTable *
430ClangASTContext::getSelectorTable()
431{
432    if (m_selector_table_ap.get() == NULL)
433        m_selector_table_ap.reset (new SelectorTable());
434    return m_selector_table_ap.get();
435}
436
437clang::FileManager *
438ClangASTContext::getFileManager()
439{
440    if (m_file_manager_ap.get() == NULL)
441    {
442        clang::FileSystemOptions file_system_options;
443        m_file_manager_ap.reset(new clang::FileManager(file_system_options));
444    }
445    return m_file_manager_ap.get();
446}
447
448clang::SourceManager *
449ClangASTContext::getSourceManager()
450{
451    if (m_source_manager_ap.get() == NULL)
452        m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager()));
453    return m_source_manager_ap.get();
454}
455
456clang::DiagnosticsEngine *
457ClangASTContext::getDiagnosticsEngine()
458{
459    if (m_diagnostics_engine_ap.get() == NULL)
460    {
461        llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs());
462        m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions()));
463    }
464    return m_diagnostics_engine_ap.get();
465}
466
467class NullDiagnosticConsumer : public DiagnosticConsumer
468{
469public:
470    NullDiagnosticConsumer ()
471    {
472        m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS);
473    }
474
475    void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info)
476    {
477        if (m_log)
478        {
479            llvm::SmallVector<char, 32> diag_str(10);
480            info.FormatDiagnostic(diag_str);
481            diag_str.push_back('\0');
482            m_log->Printf("Compiler diagnostic: %s\n", diag_str.data());
483        }
484    }
485
486    DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const
487    {
488        return new NullDiagnosticConsumer ();
489    }
490private:
491    Log * m_log;
492};
493
494DiagnosticConsumer *
495ClangASTContext::getDiagnosticConsumer()
496{
497    if (m_diagnostic_consumer_ap.get() == NULL)
498        m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer);
499
500    return m_diagnostic_consumer_ap.get();
501}
502
503TargetOptions *
504ClangASTContext::getTargetOptions()
505{
506    if (m_target_options_rp.getPtr() == NULL && !m_target_triple.empty())
507    {
508        m_target_options_rp.reset ();
509        m_target_options_rp = new TargetOptions();
510        if (m_target_options_rp.getPtr() != NULL)
511            m_target_options_rp->Triple = m_target_triple;
512    }
513    return m_target_options_rp.getPtr();
514}
515
516
517TargetInfo *
518ClangASTContext::getTargetInfo()
519{
520    // target_triple should be something like "x86_64-apple-macosx"
521    if (m_target_info_ap.get() == NULL && !m_target_triple.empty())
522        m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions()));
523    return m_target_info_ap.get();
524}
525
526#pragma mark Basic Types
527
528static inline bool
529QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type)
530{
531    uint64_t qual_type_bit_size = ast->getTypeSize(qual_type);
532    if (qual_type_bit_size == bit_size)
533        return true;
534    return false;
535}
536ClangASTType
537ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size)
538{
539    return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size);
540}
541
542ClangASTType
543ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size)
544{
545    if (!ast)
546        return ClangASTType();
547
548    switch (encoding)
549    {
550    case eEncodingInvalid:
551        if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
552            return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr());
553        break;
554
555    case eEncodingUint:
556        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
557            return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
558        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
559            return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
560        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
561            return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
562        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
563            return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
564        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
565            return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
566        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
567            return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
568        break;
569
570    case eEncodingSint:
571        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
572            return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
573        if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
574            return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
575        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
576            return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
577        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
578            return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
579        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
580            return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
581        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
582            return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
583        break;
584
585    case eEncodingIEEE754:
586        if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
587            return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
588        if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
589            return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
590        if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
591            return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
592        break;
593
594    case eEncodingVector:
595        // Sanity check that bit_size is a multiple of 8's.
596        if (bit_size && !(bit_size & 0x7u))
597            return ClangASTType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr());
598        break;
599    }
600
601    return ClangASTType();
602}
603
604
605
606lldb::BasicType
607ClangASTContext::GetBasicTypeEnumeration (const ConstString &name)
608{
609    if (name)
610    {
611        typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap;
612        static TypeNameToBasicTypeMap g_type_map;
613        static std::once_flag g_once_flag;
614        std::call_once(g_once_flag, [](){
615            // "void"
616            g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid);
617
618            // "char"
619            g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar);
620            g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar);
621            g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar);
622            g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar);
623            g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar);
624            g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar);
625            // "short"
626            g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort);
627            g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort);
628            g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort);
629            g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort);
630
631            // "int"
632            g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt);
633            g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt);
634            g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt);
635            g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt);
636
637            // "long"
638            g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong);
639            g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong);
640            g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong);
641            g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong);
642
643            // "long long"
644            g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong);
645            g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong);
646            g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong);
647            g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong);
648
649            // "int128"
650            g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128);
651            g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128);
652
653            // Miscelaneous
654            g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool);
655            g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat);
656            g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble);
657            g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble);
658            g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID);
659            g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel);
660            g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr);
661            g_type_map.Sort();
662        });
663
664        return g_type_map.Find(name.GetCString(), eBasicTypeInvalid);
665    }
666    return eBasicTypeInvalid;
667}
668
669ClangASTType
670ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name)
671{
672    if (ast)
673    {
674        lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name);
675        return ClangASTContext::GetBasicType (ast, basic_type);
676    }
677    return ClangASTType();
678}
679
680uint32_t
681ClangASTContext::GetPointerByteSize ()
682{
683    if (m_pointer_byte_size == 0)
684        m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize();
685    return m_pointer_byte_size;
686}
687
688ClangASTType
689ClangASTContext::GetBasicType (lldb::BasicType basic_type)
690{
691    return GetBasicType (getASTContext(), basic_type);
692}
693
694ClangASTType
695ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type)
696{
697    if (ast)
698    {
699        clang_type_t clang_type = NULL;
700
701        switch (basic_type)
702        {
703            case eBasicTypeInvalid:
704            case eBasicTypeOther:
705                break;
706            case eBasicTypeVoid:
707                clang_type = ast->VoidTy.getAsOpaquePtr();
708                break;
709            case eBasicTypeChar:
710                clang_type = ast->CharTy.getAsOpaquePtr();
711                break;
712            case eBasicTypeSignedChar:
713                clang_type = ast->SignedCharTy.getAsOpaquePtr();
714                break;
715            case eBasicTypeUnsignedChar:
716                clang_type = ast->UnsignedCharTy.getAsOpaquePtr();
717                break;
718            case eBasicTypeWChar:
719                clang_type = ast->getWCharType().getAsOpaquePtr();
720                break;
721            case eBasicTypeSignedWChar:
722                clang_type = ast->getSignedWCharType().getAsOpaquePtr();
723                break;
724            case eBasicTypeUnsignedWChar:
725                clang_type = ast->getUnsignedWCharType().getAsOpaquePtr();
726                break;
727            case eBasicTypeChar16:
728                clang_type = ast->Char16Ty.getAsOpaquePtr();
729                break;
730            case eBasicTypeChar32:
731                clang_type = ast->Char32Ty.getAsOpaquePtr();
732                break;
733            case eBasicTypeShort:
734                clang_type = ast->ShortTy.getAsOpaquePtr();
735                break;
736            case eBasicTypeUnsignedShort:
737                clang_type = ast->UnsignedShortTy.getAsOpaquePtr();
738                break;
739            case eBasicTypeInt:
740                clang_type = ast->IntTy.getAsOpaquePtr();
741                break;
742            case eBasicTypeUnsignedInt:
743                clang_type = ast->UnsignedIntTy.getAsOpaquePtr();
744                break;
745            case eBasicTypeLong:
746                clang_type = ast->LongTy.getAsOpaquePtr();
747                break;
748            case eBasicTypeUnsignedLong:
749                clang_type = ast->UnsignedLongTy.getAsOpaquePtr();
750                break;
751            case eBasicTypeLongLong:
752                clang_type = ast->LongLongTy.getAsOpaquePtr();
753                break;
754            case eBasicTypeUnsignedLongLong:
755                clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr();
756                break;
757            case eBasicTypeInt128:
758                clang_type = ast->Int128Ty.getAsOpaquePtr();
759                break;
760            case eBasicTypeUnsignedInt128:
761                clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr();
762                break;
763            case eBasicTypeBool:
764                clang_type = ast->BoolTy.getAsOpaquePtr();
765                break;
766            case eBasicTypeHalf:
767                clang_type = ast->HalfTy.getAsOpaquePtr();
768                break;
769            case eBasicTypeFloat:
770                clang_type = ast->FloatTy.getAsOpaquePtr();
771                break;
772            case eBasicTypeDouble:
773                clang_type = ast->DoubleTy.getAsOpaquePtr();
774                break;
775            case eBasicTypeLongDouble:
776                clang_type = ast->LongDoubleTy.getAsOpaquePtr();
777                break;
778            case eBasicTypeFloatComplex:
779                clang_type = ast->FloatComplexTy.getAsOpaquePtr();
780                break;
781            case eBasicTypeDoubleComplex:
782                clang_type = ast->DoubleComplexTy.getAsOpaquePtr();
783                break;
784            case eBasicTypeLongDoubleComplex:
785                clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr();
786                break;
787            case eBasicTypeObjCID:
788                clang_type = ast->getObjCIdType().getAsOpaquePtr();
789                break;
790            case eBasicTypeObjCClass:
791                clang_type = ast->getObjCClassType().getAsOpaquePtr();
792                break;
793            case eBasicTypeObjCSel:
794                clang_type = ast->getObjCSelType().getAsOpaquePtr();
795                break;
796            case eBasicTypeNullPtr:
797                clang_type = ast->NullPtrTy.getAsOpaquePtr();
798                break;
799        }
800
801        if (clang_type)
802            return ClangASTType (ast, clang_type);
803    }
804    return ClangASTType();
805}
806
807
808ClangASTType
809ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size)
810{
811    ASTContext *ast = getASTContext();
812
813#define streq(a,b) strcmp(a,b) == 0
814    assert (ast != NULL);
815    if (ast)
816    {
817        switch (dw_ate)
818        {
819            default:
820                break;
821
822            case DW_ATE_address:
823                if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy))
824                    return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr());
825                break;
826
827            case DW_ATE_boolean:
828                if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy))
829                    return ClangASTType (ast, ast->BoolTy.getAsOpaquePtr());
830                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
831                    return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
832                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
833                    return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
834                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
835                    return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
836                break;
837
838            case DW_ATE_lo_user:
839                // This has been seen to mean DW_AT_complex_integer
840                if (type_name)
841                {
842                    if (::strstr(type_name, "complex"))
843                    {
844                        ClangASTType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2);
845                        return ClangASTType (ast, ast->getComplexType (complex_int_clang_type.GetQualType()).getAsOpaquePtr());
846                    }
847                }
848                break;
849
850            case DW_ATE_complex_float:
851                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy))
852                    return ClangASTType (ast, ast->FloatComplexTy.getAsOpaquePtr());
853                else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy))
854                    return ClangASTType (ast, ast->DoubleComplexTy.getAsOpaquePtr());
855                else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy))
856                    return ClangASTType (ast, ast->LongDoubleComplexTy.getAsOpaquePtr());
857                else
858                {
859                    ClangASTType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2);
860                    return ClangASTType (ast, ast->getComplexType (complex_float_clang_type.GetQualType()).getAsOpaquePtr());
861                }
862                break;
863
864            case DW_ATE_float:
865                if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy))
866                    return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr());
867                if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy))
868                    return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr());
869                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy))
870                    return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr());
871                break;
872
873            case DW_ATE_signed:
874                if (type_name)
875                {
876                    if (streq(type_name, "wchar_t") &&
877                        QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy))
878                        return ClangASTType (ast, ast->WCharTy.getAsOpaquePtr());
879                    if (streq(type_name, "void") &&
880                        QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy))
881                        return ClangASTType (ast, ast->VoidTy.getAsOpaquePtr());
882                    if (strstr(type_name, "long long") &&
883                        QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
884                        return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
885                    if (strstr(type_name, "long") &&
886                        QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
887                        return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
888                    if (strstr(type_name, "short") &&
889                        QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
890                        return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
891                    if (strstr(type_name, "char"))
892                    {
893                        if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
894                            return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
895                        if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
896                            return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
897                    }
898                    if (strstr(type_name, "int"))
899                    {
900                        if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
901                            return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
902                        if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
903                            return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
904                    }
905                }
906                // We weren't able to match up a type name, just search by size
907                if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
908                    return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
909                if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy))
910                    return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr());
911                if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy))
912                    return ClangASTType (ast, ast->IntTy.getAsOpaquePtr());
913                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy))
914                    return ClangASTType (ast, ast->LongTy.getAsOpaquePtr());
915                if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy))
916                    return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr());
917                if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty))
918                    return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr());
919                break;
920
921            case DW_ATE_signed_char:
922                if (type_name)
923                {
924                    if (streq(type_name, "signed char"))
925                    {
926                        if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
927                            return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
928                    }
929                }
930                if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy))
931                    return ClangASTType (ast, ast->CharTy.getAsOpaquePtr());
932                if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy))
933                    return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr());
934                break;
935
936            case DW_ATE_unsigned:
937                if (type_name)
938                {
939                    if (strstr(type_name, "long long"))
940                    {
941                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
942                            return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
943                    }
944                    else if (strstr(type_name, "long"))
945                    {
946                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
947                            return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
948                    }
949                    else if (strstr(type_name, "short"))
950                    {
951                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
952                            return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
953                    }
954                    else if (strstr(type_name, "char"))
955                    {
956                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
957                            return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
958                    }
959                    else if (strstr(type_name, "int"))
960                    {
961                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
962                            return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
963                        if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
964                            return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
965                    }
966                }
967                // We weren't able to match up a type name, just search by size
968                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
969                    return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
970                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
971                    return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
972                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy))
973                    return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr());
974                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy))
975                    return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr());
976                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy))
977                    return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr());
978                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty))
979                    return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr());
980                break;
981
982            case DW_ATE_unsigned_char:
983                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy))
984                    return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr());
985                if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy))
986                    return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr());
987                break;
988
989            case DW_ATE_imaginary_float:
990                break;
991
992            case DW_ATE_UTF:
993                if (type_name)
994                {
995                    if (streq(type_name, "char16_t"))
996                    {
997                        return ClangASTType (ast, ast->Char16Ty.getAsOpaquePtr());
998                    }
999                    else if (streq(type_name, "char32_t"))
1000                    {
1001                        return ClangASTType (ast, ast->Char32Ty.getAsOpaquePtr());
1002                    }
1003                }
1004                break;
1005        }
1006    }
1007    // This assert should fire for anything that we don't catch above so we know
1008    // to fix any issues we run into.
1009    if (type_name)
1010    {
1011        Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type '%s' encoded with DW_ATE = 0x%x, bit_size = %u\n", type_name, dw_ate, bit_size);
1012    }
1013    else
1014    {
1015        Host::SystemLog (Host::eSystemLogError, "error: need to add support for DW_TAG_base_type encoded with DW_ATE = 0x%x, bit_size = %u\n", dw_ate, bit_size);
1016    }
1017    return ClangASTType ();
1018}
1019
1020ClangASTType
1021ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast)
1022{
1023    if (ast)
1024        return ClangASTType (ast, ast->UnknownAnyTy.getAsOpaquePtr());
1025    return ClangASTType();
1026}
1027
1028ClangASTType
1029ClangASTContext::GetCStringType (bool is_const)
1030{
1031    ASTContext *ast = getASTContext();
1032    QualType char_type(ast->CharTy);
1033
1034    if (is_const)
1035        char_type.addConst();
1036
1037    return ClangASTType (ast, ast->getPointerType(char_type).getAsOpaquePtr());
1038}
1039
1040clang::DeclContext *
1041ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast)
1042{
1043    return ast->getTranslationUnitDecl();
1044}
1045
1046ClangASTType
1047ClangASTContext::CopyType (ASTContext *dst_ast,
1048                           ClangASTType src)
1049{
1050    FileSystemOptions file_system_options;
1051    ASTContext *src_ast = src.GetASTContext();
1052    FileManager file_manager (file_system_options);
1053    ASTImporter importer(*dst_ast, file_manager,
1054                         *src_ast, file_manager,
1055                         false);
1056
1057    QualType dst (importer.Import(src.GetQualType()));
1058
1059    return ClangASTType (dst_ast, dst.getAsOpaquePtr());
1060}
1061
1062
1063clang::Decl *
1064ClangASTContext::CopyDecl (ASTContext *dst_ast,
1065                           ASTContext *src_ast,
1066                           clang::Decl *source_decl)
1067{
1068    FileSystemOptions file_system_options;
1069    FileManager file_manager (file_system_options);
1070    ASTImporter importer(*dst_ast, file_manager,
1071                         *src_ast, file_manager,
1072                         false);
1073
1074    return importer.Import(source_decl);
1075}
1076
1077bool
1078ClangASTContext::AreTypesSame (ClangASTType type1,
1079                               ClangASTType type2,
1080                               bool ignore_qualifiers)
1081{
1082    ASTContext *ast = type1.GetASTContext();
1083    if (ast != type2.GetASTContext())
1084        return false;
1085
1086    if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType())
1087        return true;
1088
1089    QualType type1_qual = type1.GetQualType();
1090    QualType type2_qual = type2.GetQualType();
1091
1092    if (ignore_qualifiers)
1093    {
1094        type1_qual = type1_qual.getUnqualifiedType();
1095        type2_qual = type2_qual.getUnqualifiedType();
1096    }
1097
1098    return ast->hasSameType (type1_qual, type2_qual);
1099}
1100
1101
1102ClangASTType
1103ClangASTContext::GetTypeForDecl (TagDecl *decl)
1104{
1105    // No need to call the getASTContext() accessor (which can create the AST
1106    // if it isn't created yet, because we can't have created a decl in this
1107    // AST if our AST didn't already exist...
1108    ASTContext *ast = m_ast_ap.get();
1109    if (ast)
1110        return ClangASTType (ast, ast->getTagDeclType(decl).getAsOpaquePtr());
1111    return ClangASTType();
1112}
1113
1114ClangASTType
1115ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl)
1116{
1117    // No need to call the getASTContext() accessor (which can create the AST
1118    // if it isn't created yet, because we can't have created a decl in this
1119    // AST if our AST didn't already exist...
1120    ASTContext *ast = m_ast_ap.get();
1121    if (ast)
1122        return ClangASTType (ast, ast->getObjCInterfaceType(decl).getAsOpaquePtr());
1123    return ClangASTType();
1124}
1125
1126#pragma mark Structure, Unions, Classes
1127
1128ClangASTType
1129ClangASTContext::CreateRecordType (DeclContext *decl_ctx,
1130                                   AccessType access_type,
1131                                   const char *name,
1132                                   int kind,
1133                                   LanguageType language,
1134                                   ClangASTMetadata *metadata)
1135{
1136    ASTContext *ast = getASTContext();
1137    assert (ast != NULL);
1138
1139    if (decl_ctx == NULL)
1140        decl_ctx = ast->getTranslationUnitDecl();
1141
1142
1143    if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus)
1144    {
1145        bool isForwardDecl = true;
1146        bool isInternal = false;
1147        return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata);
1148    }
1149
1150    // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and
1151    // we will need to update this code. I was told to currently always use
1152    // the CXXRecordDecl class since we often don't know from debug information
1153    // if something is struct or a class, so we default to always use the more
1154    // complete definition just in case.
1155
1156    bool is_anonymous = (!name) || (!name[0]);
1157
1158    CXXRecordDecl *decl = CXXRecordDecl::Create (*ast,
1159                                                 (TagDecl::TagKind)kind,
1160                                                 decl_ctx,
1161                                                 SourceLocation(),
1162                                                 SourceLocation(),
1163                                                 is_anonymous ? NULL : &ast->Idents.get(name));
1164
1165    if (is_anonymous)
1166        decl->setAnonymousStructOrUnion(true);
1167
1168    if (decl)
1169    {
1170        if (metadata)
1171            SetMetadata(ast, decl, *metadata);
1172
1173        if (access_type != eAccessNone)
1174            decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1175
1176        if (decl_ctx)
1177            decl_ctx->addDecl (decl);
1178
1179        return ClangASTType(ast, ast->getTagDeclType(decl).getAsOpaquePtr());
1180    }
1181    return ClangASTType();
1182}
1183
1184static TemplateParameterList *
1185CreateTemplateParameterList (ASTContext *ast,
1186                             const ClangASTContext::TemplateParameterInfos &template_param_infos,
1187                             llvm::SmallVector<NamedDecl *, 8> &template_param_decls)
1188{
1189    const bool parameter_pack = false;
1190    const bool is_typename = false;
1191    const unsigned depth = 0;
1192    const size_t num_template_params = template_param_infos.GetSize();
1193    for (size_t i=0; i<num_template_params; ++i)
1194    {
1195        const char *name = template_param_infos.names[i];
1196
1197        IdentifierInfo *identifier_info = NULL;
1198        if (name && name[0])
1199            identifier_info = &ast->Idents.get(name);
1200        if (template_param_infos.args[i].getKind() == TemplateArgument::Integral)
1201        {
1202            template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast,
1203                                                                             ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc,
1204                                                                             SourceLocation(),
1205                                                                             SourceLocation(),
1206                                                                             depth,
1207                                                                             i,
1208                                                                             identifier_info,
1209                                                                             template_param_infos.args[i].getIntegralType(),
1210                                                                             parameter_pack,
1211                                                                             NULL));
1212
1213        }
1214        else
1215        {
1216            template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast,
1217                                                                          ast->getTranslationUnitDecl(), // Is this the right decl context?
1218                                                                          SourceLocation(),
1219                                                                          SourceLocation(),
1220                                                                          depth,
1221                                                                          i,
1222                                                                          identifier_info,
1223                                                                          is_typename,
1224                                                                          parameter_pack));
1225        }
1226    }
1227
1228    TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast,
1229                                                                                SourceLocation(),
1230                                                                                SourceLocation(),
1231                                                                                &template_param_decls.front(),
1232                                                                                template_param_decls.size(),
1233                                                                                SourceLocation());
1234    return template_param_list;
1235}
1236
1237clang::FunctionTemplateDecl *
1238ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx,
1239                                             clang::FunctionDecl *func_decl,
1240                                             const char *name,
1241                                             const TemplateParameterInfos &template_param_infos)
1242{
1243//    /// \brief Create a function template node.
1244    ASTContext *ast = getASTContext();
1245
1246    llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1247
1248    TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1249                                                                              template_param_infos,
1250                                                                              template_param_decls);
1251    FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast,
1252                                                                         decl_ctx,
1253                                                                         func_decl->getLocation(),
1254                                                                         func_decl->getDeclName(),
1255                                                                         template_param_list,
1256                                                                         func_decl);
1257
1258    for (size_t i=0, template_param_decl_count = template_param_decls.size();
1259         i < template_param_decl_count;
1260         ++i)
1261    {
1262        // TODO: verify which decl context we should put template_param_decls into..
1263        template_param_decls[i]->setDeclContext (func_decl);
1264    }
1265
1266    return func_tmpl_decl;
1267}
1268
1269void
1270ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl,
1271                                                           clang::FunctionTemplateDecl *func_tmpl_decl,
1272                                                           const TemplateParameterInfos &infos)
1273{
1274    TemplateArgumentList template_args (TemplateArgumentList::OnStack,
1275                                        infos.args.data(),
1276                                        infos.args.size());
1277
1278    func_decl->setFunctionTemplateSpecialization (func_tmpl_decl,
1279                                                  &template_args,
1280                                                  NULL);
1281}
1282
1283
1284ClassTemplateDecl *
1285ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx,
1286                                          lldb::AccessType access_type,
1287                                          const char *class_name,
1288                                          int kind,
1289                                          const TemplateParameterInfos &template_param_infos)
1290{
1291    ASTContext *ast = getASTContext();
1292
1293    ClassTemplateDecl *class_template_decl = NULL;
1294    if (decl_ctx == NULL)
1295        decl_ctx = ast->getTranslationUnitDecl();
1296
1297    IdentifierInfo &identifier_info = ast->Idents.get(class_name);
1298    DeclarationName decl_name (&identifier_info);
1299
1300    clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1301
1302    for (NamedDecl *decl : result)
1303    {
1304        class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl);
1305        if (class_template_decl)
1306            return class_template_decl;
1307    }
1308
1309    llvm::SmallVector<NamedDecl *, 8> template_param_decls;
1310
1311    TemplateParameterList *template_param_list = CreateTemplateParameterList (ast,
1312                                                                              template_param_infos,
1313                                                                              template_param_decls);
1314
1315    CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast,
1316                                                              (TagDecl::TagKind)kind,
1317                                                              decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1318                                                              SourceLocation(),
1319                                                              SourceLocation(),
1320                                                              &identifier_info);
1321
1322    for (size_t i=0, template_param_decl_count = template_param_decls.size();
1323         i < template_param_decl_count;
1324         ++i)
1325    {
1326        template_param_decls[i]->setDeclContext (template_cxx_decl);
1327    }
1328
1329    // With templated classes, we say that a class is templated with
1330    // specializations, but that the bare class has no functions.
1331    //template_cxx_decl->startDefinition();
1332    //template_cxx_decl->completeDefinition();
1333
1334    class_template_decl = ClassTemplateDecl::Create (*ast,
1335                                                     decl_ctx,  // What decl context do we use here? TU? The actual decl context?
1336                                                     SourceLocation(),
1337                                                     decl_name,
1338                                                     template_param_list,
1339                                                     template_cxx_decl,
1340                                                     NULL);
1341
1342    if (class_template_decl)
1343    {
1344        if (access_type != eAccessNone)
1345            class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type));
1346
1347        //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx))
1348        //    CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl));
1349
1350        decl_ctx->addDecl (class_template_decl);
1351
1352#ifdef LLDB_CONFIGURATION_DEBUG
1353        VerifyDecl(class_template_decl);
1354#endif
1355    }
1356
1357    return class_template_decl;
1358}
1359
1360
1361ClassTemplateSpecializationDecl *
1362ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx,
1363                                                        ClassTemplateDecl *class_template_decl,
1364                                                        int kind,
1365                                                        const TemplateParameterInfos &template_param_infos)
1366{
1367    ASTContext *ast = getASTContext();
1368    ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast,
1369                                                                                                                   (TagDecl::TagKind)kind,
1370                                                                                                                   decl_ctx,
1371                                                                                                                   SourceLocation(),
1372                                                                                                                   SourceLocation(),
1373                                                                                                                   class_template_decl,
1374                                                                                                                   &template_param_infos.args.front(),
1375                                                                                                                   template_param_infos.args.size(),
1376                                                                                                                   NULL);
1377
1378    class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization);
1379
1380    return class_template_specialization_decl;
1381}
1382
1383ClangASTType
1384ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl)
1385{
1386    if (class_template_specialization_decl)
1387    {
1388        ASTContext *ast = getASTContext();
1389        if (ast)
1390            return ClangASTType(ast, ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr());
1391    }
1392    return ClangASTType();
1393}
1394
1395static bool
1396IsOperator (const char *name, OverloadedOperatorKind &op_kind)
1397{
1398    if (name == NULL || name[0] == '\0')
1399        return false;
1400
1401#define OPERATOR_PREFIX "operator"
1402#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1)
1403
1404    const char *post_op_name = NULL;
1405
1406    bool no_space = true;
1407
1408    if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH))
1409        return false;
1410
1411    post_op_name = name + OPERATOR_PREFIX_LENGTH;
1412
1413    if (post_op_name[0] == ' ')
1414    {
1415        post_op_name++;
1416        no_space = false;
1417    }
1418
1419#undef OPERATOR_PREFIX
1420#undef OPERATOR_PREFIX_LENGTH
1421
1422    // This is an operator, set the overloaded operator kind to invalid
1423    // in case this is a conversion operator...
1424    op_kind = NUM_OVERLOADED_OPERATORS;
1425
1426    switch (post_op_name[0])
1427    {
1428    default:
1429        if (no_space)
1430            return false;
1431        break;
1432    case 'n':
1433        if (no_space)
1434            return false;
1435        if  (strcmp (post_op_name, "new") == 0)
1436            op_kind = OO_New;
1437        else if (strcmp (post_op_name, "new[]") == 0)
1438            op_kind = OO_Array_New;
1439        break;
1440
1441    case 'd':
1442        if (no_space)
1443            return false;
1444        if (strcmp (post_op_name, "delete") == 0)
1445            op_kind = OO_Delete;
1446        else if (strcmp (post_op_name, "delete[]") == 0)
1447            op_kind = OO_Array_Delete;
1448        break;
1449
1450    case '+':
1451        if (post_op_name[1] == '\0')
1452            op_kind = OO_Plus;
1453        else if (post_op_name[2] == '\0')
1454        {
1455            if (post_op_name[1] == '=')
1456                op_kind = OO_PlusEqual;
1457            else if (post_op_name[1] == '+')
1458                op_kind = OO_PlusPlus;
1459        }
1460        break;
1461
1462    case '-':
1463        if (post_op_name[1] == '\0')
1464            op_kind = OO_Minus;
1465        else if (post_op_name[2] == '\0')
1466        {
1467            switch (post_op_name[1])
1468            {
1469            case '=': op_kind = OO_MinusEqual; break;
1470            case '-': op_kind = OO_MinusMinus; break;
1471            case '>': op_kind = OO_Arrow; break;
1472            }
1473        }
1474        else if (post_op_name[3] == '\0')
1475        {
1476            if (post_op_name[2] == '*')
1477                op_kind = OO_ArrowStar; break;
1478        }
1479        break;
1480
1481    case '*':
1482        if (post_op_name[1] == '\0')
1483            op_kind = OO_Star;
1484        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1485            op_kind = OO_StarEqual;
1486        break;
1487
1488    case '/':
1489        if (post_op_name[1] == '\0')
1490            op_kind = OO_Slash;
1491        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1492            op_kind = OO_SlashEqual;
1493        break;
1494
1495    case '%':
1496        if (post_op_name[1] == '\0')
1497            op_kind = OO_Percent;
1498        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1499            op_kind = OO_PercentEqual;
1500        break;
1501
1502
1503    case '^':
1504        if (post_op_name[1] == '\0')
1505            op_kind = OO_Caret;
1506        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1507            op_kind = OO_CaretEqual;
1508        break;
1509
1510    case '&':
1511        if (post_op_name[1] == '\0')
1512            op_kind = OO_Amp;
1513        else if (post_op_name[2] == '\0')
1514        {
1515            switch (post_op_name[1])
1516            {
1517            case '=': op_kind = OO_AmpEqual; break;
1518            case '&': op_kind = OO_AmpAmp; break;
1519            }
1520        }
1521        break;
1522
1523    case '|':
1524        if (post_op_name[1] == '\0')
1525            op_kind = OO_Pipe;
1526        else if (post_op_name[2] == '\0')
1527        {
1528            switch (post_op_name[1])
1529            {
1530            case '=': op_kind = OO_PipeEqual; break;
1531            case '|': op_kind = OO_PipePipe; break;
1532            }
1533        }
1534        break;
1535
1536    case '~':
1537        if (post_op_name[1] == '\0')
1538            op_kind = OO_Tilde;
1539        break;
1540
1541    case '!':
1542        if (post_op_name[1] == '\0')
1543            op_kind = OO_Exclaim;
1544        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1545            op_kind = OO_ExclaimEqual;
1546        break;
1547
1548    case '=':
1549        if (post_op_name[1] == '\0')
1550            op_kind = OO_Equal;
1551        else if (post_op_name[1] == '=' && post_op_name[2] == '\0')
1552            op_kind = OO_EqualEqual;
1553        break;
1554
1555    case '<':
1556        if (post_op_name[1] == '\0')
1557            op_kind = OO_Less;
1558        else if (post_op_name[2] == '\0')
1559        {
1560            switch (post_op_name[1])
1561            {
1562            case '<': op_kind = OO_LessLess; break;
1563            case '=': op_kind = OO_LessEqual; break;
1564            }
1565        }
1566        else if (post_op_name[3] == '\0')
1567        {
1568            if (post_op_name[2] == '=')
1569                op_kind = OO_LessLessEqual;
1570        }
1571        break;
1572
1573    case '>':
1574        if (post_op_name[1] == '\0')
1575            op_kind = OO_Greater;
1576        else if (post_op_name[2] == '\0')
1577        {
1578            switch (post_op_name[1])
1579            {
1580            case '>': op_kind = OO_GreaterGreater; break;
1581            case '=': op_kind = OO_GreaterEqual; break;
1582            }
1583        }
1584        else if (post_op_name[1] == '>' &&
1585                 post_op_name[2] == '=' &&
1586                 post_op_name[3] == '\0')
1587        {
1588                op_kind = OO_GreaterGreaterEqual;
1589        }
1590        break;
1591
1592    case ',':
1593        if (post_op_name[1] == '\0')
1594            op_kind = OO_Comma;
1595        break;
1596
1597    case '(':
1598        if (post_op_name[1] == ')' && post_op_name[2] == '\0')
1599            op_kind = OO_Call;
1600        break;
1601
1602    case '[':
1603        if (post_op_name[1] == ']' && post_op_name[2] == '\0')
1604            op_kind = OO_Subscript;
1605        break;
1606    }
1607
1608    return true;
1609}
1610
1611static inline bool
1612check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params)
1613{
1614    // Special-case call since it can take any number of operands
1615    if(op_kind == OO_Call)
1616        return true;
1617
1618    // The parameter count doens't include "this"
1619    if (num_params == 0)
1620        return unary;
1621    if (num_params == 1)
1622        return binary;
1623    else
1624    return false;
1625}
1626
1627bool
1628ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params)
1629{
1630    switch (op_kind)
1631    {
1632    default:
1633        break;
1634    // C++ standard allows any number of arguments to new/delete
1635    case OO_New:
1636    case OO_Array_New:
1637    case OO_Delete:
1638    case OO_Array_Delete:
1639        return true;
1640    }
1641
1642#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params);
1643    switch (op_kind)
1644    {
1645#include "clang/Basic/OperatorKinds.def"
1646        default: break;
1647    }
1648    return false;
1649}
1650
1651clang::AccessSpecifier
1652ClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs)
1653{
1654    clang::AccessSpecifier ret = lhs;
1655
1656    // Make the access equal to the stricter of the field and the nested field's access
1657    switch (ret)
1658    {
1659        case clang::AS_none:
1660            break;
1661        case clang::AS_private:
1662            break;
1663        case clang::AS_protected:
1664            if (rhs == AS_private)
1665                ret = AS_private;
1666            break;
1667        case clang::AS_public:
1668            ret = rhs;
1669            break;
1670    }
1671
1672    return ret;
1673}
1674
1675bool
1676ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size)
1677{
1678    return FieldIsBitfield(getASTContext(), field, bitfield_bit_size);
1679}
1680
1681bool
1682ClangASTContext::FieldIsBitfield
1683(
1684    ASTContext *ast,
1685    FieldDecl* field,
1686    uint32_t& bitfield_bit_size
1687)
1688{
1689    if (ast == NULL || field == NULL)
1690        return false;
1691
1692    if (field->isBitField())
1693    {
1694        Expr* bit_width_expr = field->getBitWidth();
1695        if (bit_width_expr)
1696        {
1697            llvm::APSInt bit_width_apsint;
1698            if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast))
1699            {
1700                bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX);
1701                return true;
1702            }
1703        }
1704    }
1705    return false;
1706}
1707
1708bool
1709ClangASTContext::RecordHasFields (const RecordDecl *record_decl)
1710{
1711    if (record_decl == NULL)
1712        return false;
1713
1714    if (!record_decl->field_empty())
1715        return true;
1716
1717    // No fields, lets check this is a CXX record and check the base classes
1718    const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl);
1719    if (cxx_record_decl)
1720    {
1721        CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1722        for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1723             base_class != base_class_end;
1724             ++base_class)
1725        {
1726            const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl());
1727            if (RecordHasFields(base_class_decl))
1728                return true;
1729        }
1730    }
1731    return false;
1732}
1733
1734#pragma mark Objective C Classes
1735
1736ClangASTType
1737ClangASTContext::CreateObjCClass
1738(
1739    const char *name,
1740    DeclContext *decl_ctx,
1741    bool isForwardDecl,
1742    bool isInternal,
1743    ClangASTMetadata *metadata
1744)
1745{
1746    ASTContext *ast = getASTContext();
1747    assert (ast != NULL);
1748    assert (name && name[0]);
1749    if (decl_ctx == NULL)
1750        decl_ctx = ast->getTranslationUnitDecl();
1751
1752    ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast,
1753                                                         decl_ctx,
1754                                                         SourceLocation(),
1755                                                         &ast->Idents.get(name),
1756                                                         NULL,
1757                                                         SourceLocation(),
1758                                                         /*isForwardDecl,*/
1759                                                         isInternal);
1760
1761    if (decl && metadata)
1762        SetMetadata(ast, decl, *metadata);
1763
1764    return ClangASTType (ast, ast->getObjCInterfaceType(decl));
1765}
1766
1767static inline bool
1768BaseSpecifierIsEmpty (const CXXBaseSpecifier *b)
1769{
1770    return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false;
1771}
1772
1773uint32_t
1774ClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes)
1775{
1776    uint32_t num_bases = 0;
1777    if (cxx_record_decl)
1778    {
1779        if (omit_empty_base_classes)
1780        {
1781            CXXRecordDecl::base_class_const_iterator base_class, base_class_end;
1782            for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end();
1783                 base_class != base_class_end;
1784                 ++base_class)
1785            {
1786                // Skip empty base classes
1787                if (omit_empty_base_classes)
1788                {
1789                    if (BaseSpecifierIsEmpty (base_class))
1790                        continue;
1791                }
1792                ++num_bases;
1793            }
1794        }
1795        else
1796            num_bases = cxx_record_decl->getNumBases();
1797    }
1798    return num_bases;
1799}
1800
1801
1802#pragma mark Namespace Declarations
1803
1804NamespaceDecl *
1805ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx)
1806{
1807    NamespaceDecl *namespace_decl = NULL;
1808    ASTContext *ast = getASTContext();
1809    TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl ();
1810    if (decl_ctx == NULL)
1811        decl_ctx = translation_unit_decl;
1812
1813    if (name)
1814    {
1815        IdentifierInfo &identifier_info = ast->Idents.get(name);
1816        DeclarationName decl_name (&identifier_info);
1817        clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name);
1818        for (NamedDecl *decl : result)
1819        {
1820            namespace_decl = dyn_cast<clang::NamespaceDecl>(decl);
1821            if (namespace_decl)
1822                return namespace_decl;
1823        }
1824
1825        namespace_decl = NamespaceDecl::Create(*ast,
1826                                               decl_ctx,
1827                                               false,
1828                                               SourceLocation(),
1829                                               SourceLocation(),
1830                                               &identifier_info,
1831                                               NULL);
1832
1833        decl_ctx->addDecl (namespace_decl);
1834    }
1835    else
1836    {
1837        if (decl_ctx == translation_unit_decl)
1838        {
1839            namespace_decl = translation_unit_decl->getAnonymousNamespace();
1840            if (namespace_decl)
1841                return namespace_decl;
1842
1843            namespace_decl = NamespaceDecl::Create(*ast,
1844                                                   decl_ctx,
1845                                                   false,
1846                                                   SourceLocation(),
1847                                                   SourceLocation(),
1848                                                   NULL,
1849                                                   NULL);
1850            translation_unit_decl->setAnonymousNamespace (namespace_decl);
1851            translation_unit_decl->addDecl (namespace_decl);
1852            assert (namespace_decl == translation_unit_decl->getAnonymousNamespace());
1853        }
1854        else
1855        {
1856            NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx);
1857            if (parent_namespace_decl)
1858            {
1859                namespace_decl = parent_namespace_decl->getAnonymousNamespace();
1860                if (namespace_decl)
1861                    return namespace_decl;
1862                namespace_decl = NamespaceDecl::Create(*ast,
1863                                                       decl_ctx,
1864                                                       false,
1865                                                       SourceLocation(),
1866                                                       SourceLocation(),
1867                                                       NULL,
1868                                                       NULL);
1869                parent_namespace_decl->setAnonymousNamespace (namespace_decl);
1870                parent_namespace_decl->addDecl (namespace_decl);
1871                assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace());
1872            }
1873            else
1874            {
1875                // BAD!!!
1876            }
1877        }
1878
1879
1880        if (namespace_decl)
1881        {
1882            // If we make it here, we are creating the anonymous namespace decl
1883            // for the first time, so we need to do the using directive magic
1884            // like SEMA does
1885            UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast,
1886                                                                                   decl_ctx,
1887                                                                                   SourceLocation(),
1888                                                                                   SourceLocation(),
1889                                                                                   NestedNameSpecifierLoc(),
1890                                                                                   SourceLocation(),
1891                                                                                   namespace_decl,
1892                                                                                   decl_ctx);
1893            using_directive_decl->setImplicit();
1894            decl_ctx->addDecl(using_directive_decl);
1895        }
1896    }
1897#ifdef LLDB_CONFIGURATION_DEBUG
1898    VerifyDecl(namespace_decl);
1899#endif
1900    return namespace_decl;
1901}
1902
1903
1904#pragma mark Function Types
1905
1906FunctionDecl *
1907ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx,
1908                                            const char *name,
1909                                            const ClangASTType &function_clang_type,
1910                                            int storage,
1911                                            bool is_inline)
1912{
1913    FunctionDecl *func_decl = NULL;
1914    ASTContext *ast = getASTContext();
1915    if (decl_ctx == NULL)
1916        decl_ctx = ast->getTranslationUnitDecl();
1917
1918
1919    const bool hasWrittenPrototype = true;
1920    const bool isConstexprSpecified = false;
1921
1922    if (name && name[0])
1923    {
1924        func_decl = FunctionDecl::Create (*ast,
1925                                          decl_ctx,
1926                                          SourceLocation(),
1927                                          SourceLocation(),
1928                                          DeclarationName (&ast->Idents.get(name)),
1929                                          function_clang_type.GetQualType(),
1930                                          NULL,
1931                                          (FunctionDecl::StorageClass)storage,
1932                                          is_inline,
1933                                          hasWrittenPrototype,
1934                                          isConstexprSpecified);
1935    }
1936    else
1937    {
1938        func_decl = FunctionDecl::Create (*ast,
1939                                          decl_ctx,
1940                                          SourceLocation(),
1941                                          SourceLocation(),
1942                                          DeclarationName (),
1943                                          function_clang_type.GetQualType(),
1944                                          NULL,
1945                                          (FunctionDecl::StorageClass)storage,
1946                                          is_inline,
1947                                          hasWrittenPrototype,
1948                                          isConstexprSpecified);
1949    }
1950    if (func_decl)
1951        decl_ctx->addDecl (func_decl);
1952
1953#ifdef LLDB_CONFIGURATION_DEBUG
1954    VerifyDecl(func_decl);
1955#endif
1956
1957    return func_decl;
1958}
1959
1960ClangASTType
1961ClangASTContext::CreateFunctionType (ASTContext *ast,
1962                                     const ClangASTType& result_type,
1963                                     const ClangASTType *args,
1964                                     unsigned num_args,
1965                                     bool is_variadic,
1966                                     unsigned type_quals)
1967{
1968    assert (ast != NULL);
1969    std::vector<QualType> qual_type_args;
1970    for (unsigned i=0; i<num_args; ++i)
1971        qual_type_args.push_back (args[i].GetQualType());
1972
1973    // TODO: Detect calling convention in DWARF?
1974    FunctionProtoType::ExtProtoInfo proto_info;
1975    proto_info.Variadic = is_variadic;
1976    proto_info.ExceptionSpecType = EST_None;
1977    proto_info.TypeQuals = type_quals;
1978    proto_info.RefQualifier = RQ_None;
1979    proto_info.NumExceptions = 0;
1980    proto_info.Exceptions = NULL;
1981
1982    return ClangASTType (ast, ast->getFunctionType (result_type.GetQualType(),
1983                                                    qual_type_args,
1984                                                    proto_info).getAsOpaquePtr());
1985}
1986
1987ParmVarDecl *
1988ClangASTContext::CreateParameterDeclaration (const char *name, const ClangASTType &param_type, int storage)
1989{
1990    ASTContext *ast = getASTContext();
1991    assert (ast != NULL);
1992    return ParmVarDecl::Create(*ast,
1993                                ast->getTranslationUnitDecl(),
1994                                SourceLocation(),
1995                                SourceLocation(),
1996                                name && name[0] ? &ast->Idents.get(name) : NULL,
1997                                param_type.GetQualType(),
1998                                NULL,
1999                                (VarDecl::StorageClass)storage,
2000                                0);
2001}
2002
2003void
2004ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params)
2005{
2006    if (function_decl)
2007        function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params));
2008}
2009
2010
2011#pragma mark Array Types
2012
2013ClangASTType
2014ClangASTContext::CreateArrayType (const ClangASTType &element_type,
2015                                  size_t element_count,
2016                                  bool is_vector)
2017{
2018    if (element_type.IsValid())
2019    {
2020        ASTContext *ast = getASTContext();
2021        assert (ast != NULL);
2022
2023        if (is_vector)
2024        {
2025            return ClangASTType (ast, ast->getExtVectorType(element_type.GetQualType(), element_count).getAsOpaquePtr());
2026        }
2027        else
2028        {
2029
2030            llvm::APInt ap_element_count (64, element_count);
2031            if (element_count == 0)
2032            {
2033                return ClangASTType (ast, ast->getIncompleteArrayType (element_type.GetQualType(),
2034                                                                       ArrayType::Normal,
2035                                                                       0).getAsOpaquePtr());
2036            }
2037            else
2038            {
2039                return ClangASTType (ast, ast->getConstantArrayType (element_type.GetQualType(),
2040                                                                     ap_element_count,
2041                                                                     ArrayType::Normal,
2042                                                                     0).getAsOpaquePtr());
2043            }
2044        }
2045    }
2046    return ClangASTType();
2047}
2048
2049
2050
2051#pragma mark Enumeration Types
2052
2053ClangASTType
2054ClangASTContext::CreateEnumerationType
2055(
2056    const char *name,
2057    DeclContext *decl_ctx,
2058    const Declaration &decl,
2059    const ClangASTType &integer_clang_type
2060)
2061{
2062    // TODO: Do something intelligent with the Declaration object passed in
2063    // like maybe filling in the SourceLocation with it...
2064    ASTContext *ast = getASTContext();
2065
2066    // TODO: ask about these...
2067//    const bool IsScoped = false;
2068//    const bool IsFixed = false;
2069
2070    EnumDecl *enum_decl = EnumDecl::Create (*ast,
2071                                            decl_ctx,
2072                                            SourceLocation(),
2073                                            SourceLocation(),
2074                                            name && name[0] ? &ast->Idents.get(name) : NULL,
2075                                            NULL,
2076                                            false,  // IsScoped
2077                                            false,  // IsScopedUsingClassTag
2078                                            false); // IsFixed
2079
2080
2081    if (enum_decl)
2082    {
2083        // TODO: check if we should be setting the promotion type too?
2084        enum_decl->setIntegerType(integer_clang_type.GetQualType());
2085
2086        enum_decl->setAccess(AS_public); // TODO respect what's in the debug info
2087
2088        return ClangASTType (ast, ast->getTagDeclType(enum_decl).getAsOpaquePtr());
2089    }
2090    return ClangASTType();
2091}
2092
2093// Disable this for now since I can't seem to get a nicely formatted float
2094// out of the APFloat class without just getting the float, double or quad
2095// and then using a formatted print on it which defeats the purpose. We ideally
2096// would like to get perfect string values for any kind of float semantics
2097// so we can support remote targets. The code below also requires a patch to
2098// llvm::APInt.
2099//bool
2100//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)
2101//{
2102//  uint32_t count = 0;
2103//  bool is_complex = false;
2104//  if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex))
2105//  {
2106//      unsigned num_bytes_per_float = byte_size / count;
2107//      unsigned num_bits_per_float = num_bytes_per_float * 8;
2108//
2109//      float_str.clear();
2110//      uint32_t i;
2111//      for (i=0; i<count; i++)
2112//      {
2113//          APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order);
2114//          bool is_ieee = false;
2115//          APFloat ap_float(ap_int, is_ieee);
2116//          char s[1024];
2117//          unsigned int hex_digits = 0;
2118//          bool upper_case = false;
2119//
2120//          if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0)
2121//          {
2122//              if (i > 0)
2123//                  float_str.append(", ");
2124//              float_str.append(s);
2125//              if (i == 1 && is_complex)
2126//                  float_str.append(1, 'i');
2127//          }
2128//      }
2129//      return !float_str.empty();
2130//  }
2131//  return false;
2132//}
2133
2134
2135ClangASTType
2136ClangASTContext::GetFloatTypeFromBitSize (clang::ASTContext *ast,
2137                                          size_t bit_size)
2138{
2139    if (ast)
2140    {
2141        if (bit_size == ast->getTypeSize(ast->FloatTy))
2142            return ClangASTType(ast, ast->FloatTy.getAsOpaquePtr());
2143        else if (bit_size == ast->getTypeSize(ast->DoubleTy))
2144            return ClangASTType(ast, ast->DoubleTy.getAsOpaquePtr());
2145        else if (bit_size == ast->getTypeSize(ast->LongDoubleTy))
2146            return ClangASTType(ast, ast->LongDoubleTy.getAsOpaquePtr());
2147        else if (bit_size == ast->getTypeSize(ast->HalfTy))
2148            return ClangASTType(ast, ast->HalfTy.getAsOpaquePtr());
2149    }
2150    return ClangASTType();
2151}
2152
2153bool
2154ClangASTContext::GetCompleteDecl (clang::ASTContext *ast,
2155                                  clang::Decl *decl)
2156{
2157    if (!decl)
2158        return false;
2159
2160    ExternalASTSource *ast_source = ast->getExternalSource();
2161
2162    if (!ast_source)
2163        return false;
2164
2165    if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl))
2166    {
2167        if (tag_decl->isCompleteDefinition())
2168            return true;
2169
2170        if (!tag_decl->hasExternalLexicalStorage())
2171            return false;
2172
2173        ast_source->CompleteType(tag_decl);
2174
2175        return !tag_decl->getTypeForDecl()->isIncompleteType();
2176    }
2177    else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl))
2178    {
2179        if (objc_interface_decl->getDefinition())
2180            return true;
2181
2182        if (!objc_interface_decl->hasExternalLexicalStorage())
2183            return false;
2184
2185        ast_source->CompleteType(objc_interface_decl);
2186
2187        return !objc_interface_decl->getTypeForDecl()->isIncompleteType();
2188    }
2189    else
2190    {
2191        return false;
2192    }
2193}
2194
2195void
2196ClangASTContext::SetMetadataAsUserID (const void *object,
2197                                      user_id_t user_id)
2198{
2199    ClangASTMetadata meta_data;
2200    meta_data.SetUserID (user_id);
2201    SetMetadata (object, meta_data);
2202}
2203
2204void
2205ClangASTContext::SetMetadata (clang::ASTContext *ast,
2206                              const void *object,
2207                              ClangASTMetadata &metadata)
2208{
2209    ClangExternalASTSourceCommon *external_source =
2210        static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource());
2211
2212    if (external_source)
2213        external_source->SetMetadata(object, metadata);
2214}
2215
2216ClangASTMetadata *
2217ClangASTContext::GetMetadata (clang::ASTContext *ast,
2218                              const void *object)
2219{
2220    ClangExternalASTSourceCommon *external_source =
2221        static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource());
2222
2223    if (external_source && external_source->HasMetadata(object))
2224        return external_source->GetMetadata(object);
2225    else
2226        return NULL;
2227}
2228
2229clang::DeclContext *
2230ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl)
2231{
2232    return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl);
2233}
2234
2235clang::DeclContext *
2236ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl)
2237{
2238    return llvm::dyn_cast<clang::DeclContext>(objc_method_decl);
2239}
2240
2241
2242bool
2243ClangASTContext::GetClassMethodInfoForDeclContext (clang::DeclContext *decl_ctx,
2244                                                   lldb::LanguageType &language,
2245                                                   bool &is_instance_method,
2246                                                   ConstString &language_object_name)
2247{
2248    language_object_name.Clear();
2249    language = eLanguageTypeUnknown;
2250    is_instance_method = false;
2251
2252    if (decl_ctx)
2253    {
2254        if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx))
2255        {
2256            if (method_decl->isStatic())
2257            {
2258                is_instance_method = false;
2259            }
2260            else
2261            {
2262                language_object_name.SetCString("this");
2263                is_instance_method = true;
2264            }
2265            language = eLanguageTypeC_plus_plus;
2266            return true;
2267        }
2268        else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx))
2269        {
2270            // Both static and instance methods have a "self" object in objective C
2271            language_object_name.SetCString("self");
2272            if (method_decl->isInstanceMethod())
2273            {
2274                is_instance_method = true;
2275            }
2276            else
2277            {
2278                is_instance_method = false;
2279            }
2280            language = eLanguageTypeObjC;
2281            return true;
2282        }
2283        else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx))
2284        {
2285            ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl);
2286            if (metadata && metadata->HasObjectPtr())
2287            {
2288                language_object_name.SetCString (metadata->GetObjectPtrName());
2289                language = eLanguageTypeObjC;
2290                is_instance_method = true;
2291            }
2292            return true;
2293        }
2294    }
2295    return false;
2296}
2297
2298