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