diff options
Diffstat (limited to 'contrib/llvm/tools/lldb/source/Symbol/ClangASTContext.cpp')
| -rw-r--r-- | contrib/llvm/tools/lldb/source/Symbol/ClangASTContext.cpp | 2291 |
1 files changed, 2291 insertions, 0 deletions
diff --git a/contrib/llvm/tools/lldb/source/Symbol/ClangASTContext.cpp b/contrib/llvm/tools/lldb/source/Symbol/ClangASTContext.cpp new file mode 100644 index 0000000..5ba9c6a --- /dev/null +++ b/contrib/llvm/tools/lldb/source/Symbol/ClangASTContext.cpp @@ -0,0 +1,2291 @@ +//===-- ClangASTContext.cpp -------------------------------------*- C++ -*-===// +// +// The LLVM Compiler Infrastructure +// +// This file is distributed under the University of Illinois Open Source +// License. See LICENSE.TXT for details. +// +//===----------------------------------------------------------------------===// + +#include "lldb/Symbol/ClangASTContext.h" + +// C Includes +// C++ Includes +#include <string> + +// Other libraries and framework includes + +// Clang headers like to use NDEBUG inside of them to enable/disable debug +// releated features using "#ifndef NDEBUG" preprocessor blocks to do one thing +// or another. This is bad because it means that if clang was built in release +// mode, it assumes that you are building in release mode which is not always +// the case. You can end up with functions that are defined as empty in header +// files when NDEBUG is not defined, and this can cause link errors with the +// clang .a files that you have since you might be missing functions in the .a +// file. So we have to define NDEBUG when including clang headers to avoid any +// mismatches. This is covered by rdar://problem/8691220 + +#if !defined(NDEBUG) && !defined(LLVM_NDEBUG_OFF) +#define LLDB_DEFINED_NDEBUG_FOR_CLANG +#define NDEBUG +// Need to include assert.h so it is as clang would expect it to be (disabled) +#include <assert.h> +#endif + +#include "clang/AST/ASTContext.h" +#include "clang/AST/ASTImporter.h" +#include "clang/AST/Attr.h" +#include "clang/AST/CXXInheritance.h" +#include "clang/AST/DeclObjC.h" +#include "clang/AST/DeclTemplate.h" +#include "clang/AST/RecordLayout.h" +#include "clang/AST/Type.h" +#include "clang/Basic/Builtins.h" +#include "clang/Basic/Diagnostic.h" +#include "clang/Basic/FileManager.h" +#include "clang/Basic/FileSystemOptions.h" +#include "clang/Basic/SourceManager.h" +#include "clang/Basic/TargetInfo.h" +#include "clang/Basic/TargetOptions.h" +#include "clang/Frontend/FrontendOptions.h" +#include "clang/Frontend/LangStandard.h" + +#ifdef LLDB_DEFINED_NDEBUG_FOR_CLANG +#undef NDEBUG +#undef LLDB_DEFINED_NDEBUG_FOR_CLANG +// Need to re-include assert.h so it is as _we_ would expect it to be (enabled) +#include <assert.h> +#endif + +#include "lldb/Core/ArchSpec.h" +#include "lldb/Core/dwarf.h" +#include "lldb/Core/Flags.h" +#include "lldb/Core/Log.h" +#include "lldb/Core/RegularExpression.h" +#include "lldb/Core/UniqueCStringMap.h" +#include "lldb/Expression/ASTDumper.h" +#include "lldb/Symbol/ClangExternalASTSourceCommon.h" +#include "lldb/Symbol/VerifyDecl.h" +#include "lldb/Target/ExecutionContext.h" +#include "lldb/Target/Process.h" +#include "lldb/Target/ObjCLanguageRuntime.h" + +#include <stdio.h> + +#include <mutex> + +using namespace lldb; +using namespace lldb_private; +using namespace llvm; +using namespace clang; + +clang::AccessSpecifier +ClangASTContext::ConvertAccessTypeToAccessSpecifier (AccessType access) +{ + switch (access) + { + default: break; + case eAccessNone: return AS_none; + case eAccessPublic: return AS_public; + case eAccessPrivate: return AS_private; + case eAccessProtected: return AS_protected; + } + return AS_none; +} + + +static void +ParseLangArgs +( + LangOptions &Opts, + InputKind IK +) +{ + // FIXME: Cleanup per-file based stuff. + + // Set some properties which depend soley on the input kind; it would be nice + // to move these to the language standard, and have the driver resolve the + // input kind + language standard. + if (IK == IK_Asm) { + Opts.AsmPreprocessor = 1; + } else if (IK == IK_ObjC || + IK == IK_ObjCXX || + IK == IK_PreprocessedObjC || + IK == IK_PreprocessedObjCXX) { + Opts.ObjC1 = Opts.ObjC2 = 1; + } + + LangStandard::Kind LangStd = LangStandard::lang_unspecified; + + if (LangStd == LangStandard::lang_unspecified) { + // Based on the base language, pick one. + switch (IK) { + case IK_None: + case IK_AST: + case IK_LLVM_IR: + assert (!"Invalid input kind!"); + case IK_OpenCL: + LangStd = LangStandard::lang_opencl; + break; + case IK_CUDA: + LangStd = LangStandard::lang_cuda; + break; + case IK_Asm: + case IK_C: + case IK_PreprocessedC: + case IK_ObjC: + case IK_PreprocessedObjC: + LangStd = LangStandard::lang_gnu99; + break; + case IK_CXX: + case IK_PreprocessedCXX: + case IK_ObjCXX: + case IK_PreprocessedObjCXX: + LangStd = LangStandard::lang_gnucxx98; + break; + } + } + + const LangStandard &Std = LangStandard::getLangStandardForKind(LangStd); + Opts.LineComment = Std.hasLineComments(); + Opts.C99 = Std.isC99(); + Opts.CPlusPlus = Std.isCPlusPlus(); + Opts.CPlusPlus11 = Std.isCPlusPlus11(); + Opts.Digraphs = Std.hasDigraphs(); + Opts.GNUMode = Std.isGNUMode(); + Opts.GNUInline = !Std.isC99(); + Opts.HexFloats = Std.hasHexFloats(); + Opts.ImplicitInt = Std.hasImplicitInt(); + + Opts.WChar = true; + + // OpenCL has some additional defaults. + if (LangStd == LangStandard::lang_opencl) { + Opts.OpenCL = 1; + Opts.AltiVec = 1; + Opts.CXXOperatorNames = 1; + Opts.LaxVectorConversions = 1; + } + + // OpenCL and C++ both have bool, true, false keywords. + Opts.Bool = Opts.OpenCL || Opts.CPlusPlus; + +// if (Opts.CPlusPlus) +// Opts.CXXOperatorNames = !Args.hasArg(OPT_fno_operator_names); +// +// if (Args.hasArg(OPT_fobjc_gc_only)) +// Opts.setGCMode(LangOptions::GCOnly); +// else if (Args.hasArg(OPT_fobjc_gc)) +// Opts.setGCMode(LangOptions::HybridGC); +// +// if (Args.hasArg(OPT_print_ivar_layout)) +// Opts.ObjCGCBitmapPrint = 1; +// +// if (Args.hasArg(OPT_faltivec)) +// Opts.AltiVec = 1; +// +// if (Args.hasArg(OPT_pthread)) +// Opts.POSIXThreads = 1; +// +// llvm::StringRef Vis = getLastArgValue(Args, OPT_fvisibility, +// "default"); +// if (Vis == "default") + Opts.setValueVisibilityMode(DefaultVisibility); +// else if (Vis == "hidden") +// Opts.setVisibilityMode(LangOptions::Hidden); +// else if (Vis == "protected") +// Opts.setVisibilityMode(LangOptions::Protected); +// else +// Diags.Report(diag::err_drv_invalid_value) +// << Args.getLastArg(OPT_fvisibility)->getAsString(Args) << Vis; + +// Opts.OverflowChecking = Args.hasArg(OPT_ftrapv); + + // Mimicing gcc's behavior, trigraphs are only enabled if -trigraphs + // is specified, or -std is set to a conforming mode. + Opts.Trigraphs = !Opts.GNUMode; +// if (Args.hasArg(OPT_trigraphs)) +// Opts.Trigraphs = 1; +// +// Opts.DollarIdents = Args.hasFlag(OPT_fdollars_in_identifiers, +// OPT_fno_dollars_in_identifiers, +// !Opts.AsmPreprocessor); +// Opts.PascalStrings = Args.hasArg(OPT_fpascal_strings); +// Opts.Microsoft = Args.hasArg(OPT_fms_extensions); +// Opts.WritableStrings = Args.hasArg(OPT_fwritable_strings); +// if (Args.hasArg(OPT_fno_lax_vector_conversions)) +// Opts.LaxVectorConversions = 0; +// Opts.Exceptions = Args.hasArg(OPT_fexceptions); +// Opts.RTTI = !Args.hasArg(OPT_fno_rtti); +// Opts.Blocks = Args.hasArg(OPT_fblocks); +// Opts.CharIsSigned = !Args.hasArg(OPT_fno_signed_char); +// Opts.ShortWChar = Args.hasArg(OPT_fshort_wchar); +// Opts.Freestanding = Args.hasArg(OPT_ffreestanding); +// Opts.NoBuiltin = Args.hasArg(OPT_fno_builtin) || Opts.Freestanding; +// Opts.AssumeSaneOperatorNew = !Args.hasArg(OPT_fno_assume_sane_operator_new); +// Opts.HeinousExtensions = Args.hasArg(OPT_fheinous_gnu_extensions); +// Opts.AccessControl = Args.hasArg(OPT_faccess_control); +// Opts.ElideConstructors = !Args.hasArg(OPT_fno_elide_constructors); +// Opts.MathErrno = !Args.hasArg(OPT_fno_math_errno); +// Opts.InstantiationDepth = getLastArgIntValue(Args, OPT_ftemplate_depth, 99, +// Diags); +// Opts.NeXTRuntime = !Args.hasArg(OPT_fgnu_runtime); +// Opts.ObjCConstantStringClass = getLastArgValue(Args, +// OPT_fconstant_string_class); +// Opts.ObjCNonFragileABI = Args.hasArg(OPT_fobjc_nonfragile_abi); +// Opts.CatchUndefined = Args.hasArg(OPT_fcatch_undefined_behavior); +// Opts.EmitAllDecls = Args.hasArg(OPT_femit_all_decls); +// Opts.PICLevel = getLastArgIntValue(Args, OPT_pic_level, 0, Diags); +// Opts.Static = Args.hasArg(OPT_static_define); + Opts.OptimizeSize = 0; + + // FIXME: Eliminate this dependency. +// unsigned Opt = +// Args.hasArg(OPT_Os) ? 2 : getLastArgIntValue(Args, OPT_O, 0, Diags); +// Opts.Optimize = Opt != 0; + unsigned Opt = 0; + + // This is the __NO_INLINE__ define, which just depends on things like the + // optimization level and -fno-inline, not actually whether the backend has + // inlining enabled. + // + // FIXME: This is affected by other options (-fno-inline). + Opts.NoInlineDefine = !Opt; + +// unsigned SSP = getLastArgIntValue(Args, OPT_stack_protector, 0, Diags); +// switch (SSP) { +// default: +// Diags.Report(diag::err_drv_invalid_value) +// << Args.getLastArg(OPT_stack_protector)->getAsString(Args) << SSP; +// break; +// case 0: Opts.setStackProtectorMode(LangOptions::SSPOff); break; +// case 1: Opts.setStackProtectorMode(LangOptions::SSPOn); break; +// case 2: Opts.setStackProtectorMode(LangOptions::SSPReq); break; +// } +} + + +ClangASTContext::ClangASTContext (const char *target_triple) : + m_target_triple(), + m_ast_ap(), + m_language_options_ap(), + m_source_manager_ap(), + m_diagnostics_engine_ap(), + m_target_options_rp(), + m_target_info_ap(), + m_identifier_table_ap(), + m_selector_table_ap(), + m_builtins_ap(), + m_callback_tag_decl (NULL), + m_callback_objc_decl (NULL), + m_callback_baton (NULL), + m_pointer_byte_size (0) + +{ + if (target_triple && target_triple[0]) + SetTargetTriple (target_triple); +} + +//---------------------------------------------------------------------- +// Destructor +//---------------------------------------------------------------------- +ClangASTContext::~ClangASTContext() +{ + m_builtins_ap.reset(); + m_selector_table_ap.reset(); + m_identifier_table_ap.reset(); + m_target_info_ap.reset(); + m_target_options_rp.reset(); + m_diagnostics_engine_ap.reset(); + m_source_manager_ap.reset(); + m_language_options_ap.reset(); + m_ast_ap.reset(); +} + + +void +ClangASTContext::Clear() +{ + m_ast_ap.reset(); + m_language_options_ap.reset(); + m_source_manager_ap.reset(); + m_diagnostics_engine_ap.reset(); + m_target_options_rp.reset(); + m_target_info_ap.reset(); + m_identifier_table_ap.reset(); + m_selector_table_ap.reset(); + m_builtins_ap.reset(); + m_pointer_byte_size = 0; +} + +const char * +ClangASTContext::GetTargetTriple () +{ + return m_target_triple.c_str(); +} + +void +ClangASTContext::SetTargetTriple (const char *target_triple) +{ + Clear(); + m_target_triple.assign(target_triple); +} + +void +ClangASTContext::SetArchitecture (const ArchSpec &arch) +{ + SetTargetTriple(arch.GetTriple().str().c_str()); +} + +bool +ClangASTContext::HasExternalSource () +{ + ASTContext *ast = getASTContext(); + if (ast) + return ast->getExternalSource () != NULL; + return false; +} + +void +ClangASTContext::SetExternalSource (llvm::OwningPtr<ExternalASTSource> &ast_source_ap) +{ + ASTContext *ast = getASTContext(); + if (ast) + { + ast->setExternalSource (ast_source_ap); + ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(true); + //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(true); + } +} + +void +ClangASTContext::RemoveExternalSource () +{ + ASTContext *ast = getASTContext(); + + if (ast) + { + llvm::OwningPtr<ExternalASTSource> empty_ast_source_ap; + ast->setExternalSource (empty_ast_source_ap); + ast->getTranslationUnitDecl()->setHasExternalLexicalStorage(false); + //ast->getTranslationUnitDecl()->setHasExternalVisibleStorage(false); + } +} + + + +ASTContext * +ClangASTContext::getASTContext() +{ + if (m_ast_ap.get() == NULL) + { + m_ast_ap.reset(new ASTContext (*getLanguageOptions(), + *getSourceManager(), + getTargetInfo(), + *getIdentifierTable(), + *getSelectorTable(), + *getBuiltinContext(), + 0)); + + if ((m_callback_tag_decl || m_callback_objc_decl) && m_callback_baton) + { + m_ast_ap->getTranslationUnitDecl()->setHasExternalLexicalStorage(); + //m_ast_ap->getTranslationUnitDecl()->setHasExternalVisibleStorage(); + } + + m_ast_ap->getDiagnostics().setClient(getDiagnosticConsumer(), false); + } + return m_ast_ap.get(); +} + +Builtin::Context * +ClangASTContext::getBuiltinContext() +{ + if (m_builtins_ap.get() == NULL) + m_builtins_ap.reset (new Builtin::Context()); + return m_builtins_ap.get(); +} + +IdentifierTable * +ClangASTContext::getIdentifierTable() +{ + if (m_identifier_table_ap.get() == NULL) + m_identifier_table_ap.reset(new IdentifierTable (*ClangASTContext::getLanguageOptions(), NULL)); + return m_identifier_table_ap.get(); +} + +LangOptions * +ClangASTContext::getLanguageOptions() +{ + if (m_language_options_ap.get() == NULL) + { + m_language_options_ap.reset(new LangOptions()); + ParseLangArgs(*m_language_options_ap, IK_ObjCXX); +// InitializeLangOptions(*m_language_options_ap, IK_ObjCXX); + } + return m_language_options_ap.get(); +} + +SelectorTable * +ClangASTContext::getSelectorTable() +{ + if (m_selector_table_ap.get() == NULL) + m_selector_table_ap.reset (new SelectorTable()); + return m_selector_table_ap.get(); +} + +clang::FileManager * +ClangASTContext::getFileManager() +{ + if (m_file_manager_ap.get() == NULL) + { + clang::FileSystemOptions file_system_options; + m_file_manager_ap.reset(new clang::FileManager(file_system_options)); + } + return m_file_manager_ap.get(); +} + +clang::SourceManager * +ClangASTContext::getSourceManager() +{ + if (m_source_manager_ap.get() == NULL) + m_source_manager_ap.reset(new clang::SourceManager(*getDiagnosticsEngine(), *getFileManager())); + return m_source_manager_ap.get(); +} + +clang::DiagnosticsEngine * +ClangASTContext::getDiagnosticsEngine() +{ + if (m_diagnostics_engine_ap.get() == NULL) + { + llvm::IntrusiveRefCntPtr<DiagnosticIDs> diag_id_sp(new DiagnosticIDs()); + m_diagnostics_engine_ap.reset(new DiagnosticsEngine(diag_id_sp, new DiagnosticOptions())); + } + return m_diagnostics_engine_ap.get(); +} + +class NullDiagnosticConsumer : public DiagnosticConsumer +{ +public: + NullDiagnosticConsumer () + { + m_log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS); + } + + void HandleDiagnostic (DiagnosticsEngine::Level DiagLevel, const Diagnostic &info) + { + if (m_log) + { + llvm::SmallVector<char, 32> diag_str(10); + info.FormatDiagnostic(diag_str); + diag_str.push_back('\0'); + m_log->Printf("Compiler diagnostic: %s\n", diag_str.data()); + } + } + + DiagnosticConsumer *clone (DiagnosticsEngine &Diags) const + { + return new NullDiagnosticConsumer (); + } +private: + Log * m_log; +}; + +DiagnosticConsumer * +ClangASTContext::getDiagnosticConsumer() +{ + if (m_diagnostic_consumer_ap.get() == NULL) + m_diagnostic_consumer_ap.reset(new NullDiagnosticConsumer); + + return m_diagnostic_consumer_ap.get(); +} + +TargetOptions * +ClangASTContext::getTargetOptions() +{ + if (m_target_options_rp.getPtr() == NULL && !m_target_triple.empty()) + { + m_target_options_rp.reset (); + m_target_options_rp = new TargetOptions(); + if (m_target_options_rp.getPtr() != NULL) + m_target_options_rp->Triple = m_target_triple; + } + return m_target_options_rp.getPtr(); +} + + +TargetInfo * +ClangASTContext::getTargetInfo() +{ + // target_triple should be something like "x86_64-apple-macosx" + if (m_target_info_ap.get() == NULL && !m_target_triple.empty()) + m_target_info_ap.reset (TargetInfo::CreateTargetInfo(*getDiagnosticsEngine(), getTargetOptions())); + return m_target_info_ap.get(); +} + +#pragma mark Basic Types + +static inline bool +QualTypeMatchesBitSize(const uint64_t bit_size, ASTContext *ast, QualType qual_type) +{ + uint64_t qual_type_bit_size = ast->getTypeSize(qual_type); + if (qual_type_bit_size == bit_size) + return true; + return false; +} +ClangASTType +ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (Encoding encoding, uint32_t bit_size) +{ + return ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (getASTContext(), encoding, bit_size); +} + +ClangASTType +ClangASTContext::GetBuiltinTypeForEncodingAndBitSize (ASTContext *ast, Encoding encoding, uint32_t bit_size) +{ + if (!ast) + return ClangASTType(); + + switch (encoding) + { + case eEncodingInvalid: + if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) + return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr()); + break; + + case eEncodingUint: + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) + return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) + return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) + return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) + return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) + return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) + return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); + break; + + case eEncodingSint: + if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) + return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) + return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) + return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) + return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) + return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) + return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); + break; + + case eEncodingIEEE754: + if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) + return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) + return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) + return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr()); + break; + + case eEncodingVector: + // Sanity check that bit_size is a multiple of 8's. + if (bit_size && !(bit_size & 0x7u)) + return ClangASTType (ast, ast->getExtVectorType (ast->UnsignedCharTy, bit_size/8).getAsOpaquePtr()); + break; + } + + return ClangASTType(); +} + + + +lldb::BasicType +ClangASTContext::GetBasicTypeEnumeration (const ConstString &name) +{ + if (name) + { + typedef UniqueCStringMap<lldb::BasicType> TypeNameToBasicTypeMap; + static TypeNameToBasicTypeMap g_type_map; + static std::once_flag g_once_flag; + std::call_once(g_once_flag, [](){ + // "void" + g_type_map.Append(ConstString("void").GetCString(), eBasicTypeVoid); + + // "char" + g_type_map.Append(ConstString("char").GetCString(), eBasicTypeChar); + g_type_map.Append(ConstString("signed char").GetCString(), eBasicTypeSignedChar); + g_type_map.Append(ConstString("unsigned char").GetCString(), eBasicTypeUnsignedChar); + g_type_map.Append(ConstString("wchar_t").GetCString(), eBasicTypeWChar); + g_type_map.Append(ConstString("signed wchar_t").GetCString(), eBasicTypeSignedWChar); + g_type_map.Append(ConstString("unsigned wchar_t").GetCString(), eBasicTypeUnsignedWChar); + // "short" + g_type_map.Append(ConstString("short").GetCString(), eBasicTypeShort); + g_type_map.Append(ConstString("short int").GetCString(), eBasicTypeShort); + g_type_map.Append(ConstString("unsigned short").GetCString(), eBasicTypeUnsignedShort); + g_type_map.Append(ConstString("unsigned short int").GetCString(), eBasicTypeUnsignedShort); + + // "int" + g_type_map.Append(ConstString("int").GetCString(), eBasicTypeInt); + g_type_map.Append(ConstString("signed int").GetCString(), eBasicTypeInt); + g_type_map.Append(ConstString("unsigned int").GetCString(), eBasicTypeUnsignedInt); + g_type_map.Append(ConstString("unsigned").GetCString(), eBasicTypeUnsignedInt); + + // "long" + g_type_map.Append(ConstString("long").GetCString(), eBasicTypeLong); + g_type_map.Append(ConstString("long int").GetCString(), eBasicTypeLong); + g_type_map.Append(ConstString("unsigned long").GetCString(), eBasicTypeUnsignedLong); + g_type_map.Append(ConstString("unsigned long int").GetCString(), eBasicTypeUnsignedLong); + + // "long long" + g_type_map.Append(ConstString("long long").GetCString(), eBasicTypeLongLong); + g_type_map.Append(ConstString("long long int").GetCString(), eBasicTypeLongLong); + g_type_map.Append(ConstString("unsigned long long").GetCString(), eBasicTypeUnsignedLongLong); + g_type_map.Append(ConstString("unsigned long long int").GetCString(), eBasicTypeUnsignedLongLong); + + // "int128" + g_type_map.Append(ConstString("__int128_t").GetCString(), eBasicTypeInt128); + g_type_map.Append(ConstString("__uint128_t").GetCString(), eBasicTypeUnsignedInt128); + + // Miscelaneous + g_type_map.Append(ConstString("bool").GetCString(), eBasicTypeBool); + g_type_map.Append(ConstString("float").GetCString(), eBasicTypeFloat); + g_type_map.Append(ConstString("double").GetCString(), eBasicTypeDouble); + g_type_map.Append(ConstString("long double").GetCString(), eBasicTypeLongDouble); + g_type_map.Append(ConstString("id").GetCString(), eBasicTypeObjCID); + g_type_map.Append(ConstString("SEL").GetCString(), eBasicTypeObjCSel); + g_type_map.Append(ConstString("nullptr").GetCString(), eBasicTypeNullPtr); + g_type_map.Sort(); + }); + + return g_type_map.Find(name.GetCString(), eBasicTypeInvalid); + } + return eBasicTypeInvalid; +} + +ClangASTType +ClangASTContext::GetBasicType (ASTContext *ast, const ConstString &name) +{ + if (ast) + { + lldb::BasicType basic_type = ClangASTContext::GetBasicTypeEnumeration (name); + return ClangASTContext::GetBasicType (ast, basic_type); + } + return ClangASTType(); +} + +uint32_t +ClangASTContext::GetPointerByteSize () +{ + if (m_pointer_byte_size == 0) + m_pointer_byte_size = GetBasicType(lldb::eBasicTypeVoid).GetPointerType().GetByteSize(); + return m_pointer_byte_size; +} + +ClangASTType +ClangASTContext::GetBasicType (lldb::BasicType basic_type) +{ + return GetBasicType (getASTContext(), basic_type); +} + +ClangASTType +ClangASTContext::GetBasicType (ASTContext *ast, lldb::BasicType basic_type) +{ + if (ast) + { + clang_type_t clang_type = NULL; + + switch (basic_type) + { + case eBasicTypeInvalid: + case eBasicTypeOther: + break; + case eBasicTypeVoid: + clang_type = ast->VoidTy.getAsOpaquePtr(); + break; + case eBasicTypeChar: + clang_type = ast->CharTy.getAsOpaquePtr(); + break; + case eBasicTypeSignedChar: + clang_type = ast->SignedCharTy.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedChar: + clang_type = ast->UnsignedCharTy.getAsOpaquePtr(); + break; + case eBasicTypeWChar: + clang_type = ast->getWCharType().getAsOpaquePtr(); + break; + case eBasicTypeSignedWChar: + clang_type = ast->getSignedWCharType().getAsOpaquePtr(); + break; + case eBasicTypeUnsignedWChar: + clang_type = ast->getUnsignedWCharType().getAsOpaquePtr(); + break; + case eBasicTypeChar16: + clang_type = ast->Char16Ty.getAsOpaquePtr(); + break; + case eBasicTypeChar32: + clang_type = ast->Char32Ty.getAsOpaquePtr(); + break; + case eBasicTypeShort: + clang_type = ast->ShortTy.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedShort: + clang_type = ast->UnsignedShortTy.getAsOpaquePtr(); + break; + case eBasicTypeInt: + clang_type = ast->IntTy.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedInt: + clang_type = ast->UnsignedIntTy.getAsOpaquePtr(); + break; + case eBasicTypeLong: + clang_type = ast->LongTy.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedLong: + clang_type = ast->UnsignedLongTy.getAsOpaquePtr(); + break; + case eBasicTypeLongLong: + clang_type = ast->LongLongTy.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedLongLong: + clang_type = ast->UnsignedLongLongTy.getAsOpaquePtr(); + break; + case eBasicTypeInt128: + clang_type = ast->Int128Ty.getAsOpaquePtr(); + break; + case eBasicTypeUnsignedInt128: + clang_type = ast->UnsignedInt128Ty.getAsOpaquePtr(); + break; + case eBasicTypeBool: + clang_type = ast->BoolTy.getAsOpaquePtr(); + break; + case eBasicTypeHalf: + clang_type = ast->HalfTy.getAsOpaquePtr(); + break; + case eBasicTypeFloat: + clang_type = ast->FloatTy.getAsOpaquePtr(); + break; + case eBasicTypeDouble: + clang_type = ast->DoubleTy.getAsOpaquePtr(); + break; + case eBasicTypeLongDouble: + clang_type = ast->LongDoubleTy.getAsOpaquePtr(); + break; + case eBasicTypeFloatComplex: + clang_type = ast->FloatComplexTy.getAsOpaquePtr(); + break; + case eBasicTypeDoubleComplex: + clang_type = ast->DoubleComplexTy.getAsOpaquePtr(); + break; + case eBasicTypeLongDoubleComplex: + clang_type = ast->LongDoubleComplexTy.getAsOpaquePtr(); + break; + case eBasicTypeObjCID: + clang_type = ast->getObjCIdType().getAsOpaquePtr(); + break; + case eBasicTypeObjCClass: + clang_type = ast->getObjCClassType().getAsOpaquePtr(); + break; + case eBasicTypeObjCSel: + clang_type = ast->getObjCSelType().getAsOpaquePtr(); + break; + case eBasicTypeNullPtr: + clang_type = ast->NullPtrTy.getAsOpaquePtr(); + break; + } + + if (clang_type) + return ClangASTType (ast, clang_type); + } + return ClangASTType(); +} + + +ClangASTType +ClangASTContext::GetBuiltinTypeForDWARFEncodingAndBitSize (const char *type_name, uint32_t dw_ate, uint32_t bit_size) +{ + ASTContext *ast = getASTContext(); + +#define streq(a,b) strcmp(a,b) == 0 + assert (ast != NULL); + if (ast) + { + switch (dw_ate) + { + default: + break; + + case DW_ATE_address: + if (QualTypeMatchesBitSize (bit_size, ast, ast->VoidPtrTy)) + return ClangASTType (ast, ast->VoidPtrTy.getAsOpaquePtr()); + break; + + case DW_ATE_boolean: + if (QualTypeMatchesBitSize (bit_size, ast, ast->BoolTy)) + return ClangASTType (ast, ast->BoolTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) + return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) + return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) + return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); + break; + + case DW_ATE_lo_user: + // This has been seen to mean DW_AT_complex_integer + if (type_name) + { + if (::strstr(type_name, "complex")) + { + ClangASTType complex_int_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("int", DW_ATE_signed, bit_size/2); + return ClangASTType (ast, ast->getComplexType (complex_int_clang_type.GetQualType()).getAsOpaquePtr()); + } + } + break; + + case DW_ATE_complex_float: + if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatComplexTy)) + return ClangASTType (ast, ast->FloatComplexTy.getAsOpaquePtr()); + else if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleComplexTy)) + return ClangASTType (ast, ast->DoubleComplexTy.getAsOpaquePtr()); + else if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleComplexTy)) + return ClangASTType (ast, ast->LongDoubleComplexTy.getAsOpaquePtr()); + else + { + ClangASTType complex_float_clang_type = GetBuiltinTypeForDWARFEncodingAndBitSize ("float", DW_ATE_float, bit_size/2); + return ClangASTType (ast, ast->getComplexType (complex_float_clang_type.GetQualType()).getAsOpaquePtr()); + } + break; + + case DW_ATE_float: + if (QualTypeMatchesBitSize (bit_size, ast, ast->FloatTy)) + return ClangASTType (ast, ast->FloatTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->DoubleTy)) + return ClangASTType (ast, ast->DoubleTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongDoubleTy)) + return ClangASTType (ast, ast->LongDoubleTy.getAsOpaquePtr()); + break; + + case DW_ATE_signed: + if (type_name) + { + if (streq(type_name, "wchar_t") && + QualTypeMatchesBitSize (bit_size, ast, ast->WCharTy)) + return ClangASTType (ast, ast->WCharTy.getAsOpaquePtr()); + if (streq(type_name, "void") && + QualTypeMatchesBitSize (bit_size, ast, ast->VoidTy)) + return ClangASTType (ast, ast->VoidTy.getAsOpaquePtr()); + if (strstr(type_name, "long long") && + QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) + return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); + if (strstr(type_name, "long") && + QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) + return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); + if (strstr(type_name, "short") && + QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) + return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); + if (strstr(type_name, "char")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) + return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) + return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); + } + if (strstr(type_name, "int")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) + return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) + return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); + } + } + // We weren't able to match up a type name, just search by size + if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) + return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->ShortTy)) + return ClangASTType (ast, ast->ShortTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->IntTy)) + return ClangASTType (ast, ast->IntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongTy)) + return ClangASTType (ast, ast->LongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->LongLongTy)) + return ClangASTType (ast, ast->LongLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->Int128Ty)) + return ClangASTType (ast, ast->Int128Ty.getAsOpaquePtr()); + break; + + case DW_ATE_signed_char: + if (type_name) + { + if (streq(type_name, "signed char")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) + return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); + } + } + if (QualTypeMatchesBitSize (bit_size, ast, ast->CharTy)) + return ClangASTType (ast, ast->CharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->SignedCharTy)) + return ClangASTType (ast, ast->SignedCharTy.getAsOpaquePtr()); + break; + + case DW_ATE_unsigned: + if (type_name) + { + if (strstr(type_name, "long long")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) + return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); + } + else if (strstr(type_name, "long")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) + return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); + } + else if (strstr(type_name, "short")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) + return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); + } + else if (strstr(type_name, "char")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) + return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); + } + else if (strstr(type_name, "int")) + { + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) + return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) + return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); + } + } + // We weren't able to match up a type name, just search by size + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) + return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) + return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedIntTy)) + return ClangASTType (ast, ast->UnsignedIntTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongTy)) + return ClangASTType (ast, ast->UnsignedLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedLongLongTy)) + return ClangASTType (ast, ast->UnsignedLongLongTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedInt128Ty)) + return ClangASTType (ast, ast->UnsignedInt128Ty.getAsOpaquePtr()); + break; + + case DW_ATE_unsigned_char: + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedCharTy)) + return ClangASTType (ast, ast->UnsignedCharTy.getAsOpaquePtr()); + if (QualTypeMatchesBitSize (bit_size, ast, ast->UnsignedShortTy)) + return ClangASTType (ast, ast->UnsignedShortTy.getAsOpaquePtr()); + break; + + case DW_ATE_imaginary_float: + break; + + case DW_ATE_UTF: + if (type_name) + { + if (streq(type_name, "char16_t")) + { + return ClangASTType (ast, ast->Char16Ty.getAsOpaquePtr()); + } + else if (streq(type_name, "char32_t")) + { + return ClangASTType (ast, ast->Char32Ty.getAsOpaquePtr()); + } + } + break; + } + } + // This assert should fire for anything that we don't catch above so we know + // to fix any issues we run into. + if (type_name) + { + 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); + } + else + { + 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); + } + return ClangASTType (); +} + +ClangASTType +ClangASTContext::GetUnknownAnyType(clang::ASTContext *ast) +{ + if (ast) + return ClangASTType (ast, ast->UnknownAnyTy.getAsOpaquePtr()); + return ClangASTType(); +} + +ClangASTType +ClangASTContext::GetCStringType (bool is_const) +{ + ASTContext *ast = getASTContext(); + QualType char_type(ast->CharTy); + + if (is_const) + char_type.addConst(); + + return ClangASTType (ast, ast->getPointerType(char_type).getAsOpaquePtr()); +} + +clang::DeclContext * +ClangASTContext::GetTranslationUnitDecl (clang::ASTContext *ast) +{ + return ast->getTranslationUnitDecl(); +} + +ClangASTType +ClangASTContext::CopyType (ASTContext *dst_ast, + ClangASTType src) +{ + FileSystemOptions file_system_options; + ASTContext *src_ast = src.GetASTContext(); + FileManager file_manager (file_system_options); + ASTImporter importer(*dst_ast, file_manager, + *src_ast, file_manager, + false); + + QualType dst (importer.Import(src.GetQualType())); + + return ClangASTType (dst_ast, dst.getAsOpaquePtr()); +} + + +clang::Decl * +ClangASTContext::CopyDecl (ASTContext *dst_ast, + ASTContext *src_ast, + clang::Decl *source_decl) +{ + FileSystemOptions file_system_options; + FileManager file_manager (file_system_options); + ASTImporter importer(*dst_ast, file_manager, + *src_ast, file_manager, + false); + + return importer.Import(source_decl); +} + +bool +ClangASTContext::AreTypesSame (ClangASTType type1, + ClangASTType type2, + bool ignore_qualifiers) +{ + ASTContext *ast = type1.GetASTContext(); + if (ast != type2.GetASTContext()) + return false; + + if (type1.GetOpaqueQualType() == type2.GetOpaqueQualType()) + return true; + + QualType type1_qual = type1.GetQualType(); + QualType type2_qual = type2.GetQualType(); + + if (ignore_qualifiers) + { + type1_qual = type1_qual.getUnqualifiedType(); + type2_qual = type2_qual.getUnqualifiedType(); + } + + return ast->hasSameType (type1_qual, type2_qual); +} + + +ClangASTType +ClangASTContext::GetTypeForDecl (TagDecl *decl) +{ + // No need to call the getASTContext() accessor (which can create the AST + // if it isn't created yet, because we can't have created a decl in this + // AST if our AST didn't already exist... + ASTContext *ast = m_ast_ap.get(); + if (ast) + return ClangASTType (ast, ast->getTagDeclType(decl).getAsOpaquePtr()); + return ClangASTType(); +} + +ClangASTType +ClangASTContext::GetTypeForDecl (ObjCInterfaceDecl *decl) +{ + // No need to call the getASTContext() accessor (which can create the AST + // if it isn't created yet, because we can't have created a decl in this + // AST if our AST didn't already exist... + ASTContext *ast = m_ast_ap.get(); + if (ast) + return ClangASTType (ast, ast->getObjCInterfaceType(decl).getAsOpaquePtr()); + return ClangASTType(); +} + +#pragma mark Structure, Unions, Classes + +ClangASTType +ClangASTContext::CreateRecordType (DeclContext *decl_ctx, + AccessType access_type, + const char *name, + int kind, + LanguageType language, + ClangASTMetadata *metadata) +{ + ASTContext *ast = getASTContext(); + assert (ast != NULL); + + if (decl_ctx == NULL) + decl_ctx = ast->getTranslationUnitDecl(); + + + if (language == eLanguageTypeObjC || language == eLanguageTypeObjC_plus_plus) + { + bool isForwardDecl = true; + bool isInternal = false; + return CreateObjCClass (name, decl_ctx, isForwardDecl, isInternal, metadata); + } + + // NOTE: Eventually CXXRecordDecl will be merged back into RecordDecl and + // we will need to update this code. I was told to currently always use + // the CXXRecordDecl class since we often don't know from debug information + // if something is struct or a class, so we default to always use the more + // complete definition just in case. + CXXRecordDecl *decl = CXXRecordDecl::Create (*ast, + (TagDecl::TagKind)kind, + decl_ctx, + SourceLocation(), + SourceLocation(), + name && name[0] ? &ast->Idents.get(name) : NULL); + + if (decl) + { + if (metadata) + SetMetadata(ast, decl, *metadata); + + if (access_type != eAccessNone) + decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); + + if (decl_ctx) + decl_ctx->addDecl (decl); + + return ClangASTType(ast, ast->getTagDeclType(decl).getAsOpaquePtr()); + } + return ClangASTType(); +} + +static TemplateParameterList * +CreateTemplateParameterList (ASTContext *ast, + const ClangASTContext::TemplateParameterInfos &template_param_infos, + llvm::SmallVector<NamedDecl *, 8> &template_param_decls) +{ + const bool parameter_pack = false; + const bool is_typename = false; + const unsigned depth = 0; + const size_t num_template_params = template_param_infos.GetSize(); + for (size_t i=0; i<num_template_params; ++i) + { + const char *name = template_param_infos.names[i]; + + IdentifierInfo *identifier_info = NULL; + if (name && name[0]) + identifier_info = &ast->Idents.get(name); + if (template_param_infos.args[i].getKind() == TemplateArgument::Integral) + { + template_param_decls.push_back (NonTypeTemplateParmDecl::Create (*ast, + ast->getTranslationUnitDecl(), // Is this the right decl context?, SourceLocation StartLoc, + SourceLocation(), + SourceLocation(), + depth, + i, + identifier_info, + template_param_infos.args[i].getIntegralType(), + parameter_pack, + NULL)); + + } + else + { + template_param_decls.push_back (TemplateTypeParmDecl::Create (*ast, + ast->getTranslationUnitDecl(), // Is this the right decl context? + SourceLocation(), + SourceLocation(), + depth, + i, + identifier_info, + is_typename, + parameter_pack)); + } + } + + TemplateParameterList *template_param_list = TemplateParameterList::Create (*ast, + SourceLocation(), + SourceLocation(), + &template_param_decls.front(), + template_param_decls.size(), + SourceLocation()); + return template_param_list; +} + +clang::FunctionTemplateDecl * +ClangASTContext::CreateFunctionTemplateDecl (clang::DeclContext *decl_ctx, + clang::FunctionDecl *func_decl, + const char *name, + const TemplateParameterInfos &template_param_infos) +{ +// /// \brief Create a function template node. + ASTContext *ast = getASTContext(); + + llvm::SmallVector<NamedDecl *, 8> template_param_decls; + + TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, + template_param_infos, + template_param_decls); + FunctionTemplateDecl *func_tmpl_decl = FunctionTemplateDecl::Create (*ast, + decl_ctx, + func_decl->getLocation(), + func_decl->getDeclName(), + template_param_list, + func_decl); + + for (size_t i=0, template_param_decl_count = template_param_decls.size(); + i < template_param_decl_count; + ++i) + { + // TODO: verify which decl context we should put template_param_decls into.. + template_param_decls[i]->setDeclContext (func_decl); + } + + return func_tmpl_decl; +} + +void +ClangASTContext::CreateFunctionTemplateSpecializationInfo (FunctionDecl *func_decl, + clang::FunctionTemplateDecl *func_tmpl_decl, + const TemplateParameterInfos &infos) +{ + TemplateArgumentList template_args (TemplateArgumentList::OnStack, + infos.args.data(), + infos.args.size()); + + func_decl->setFunctionTemplateSpecialization (func_tmpl_decl, + &template_args, + NULL); +} + + +ClassTemplateDecl * +ClangASTContext::CreateClassTemplateDecl (DeclContext *decl_ctx, + lldb::AccessType access_type, + const char *class_name, + int kind, + const TemplateParameterInfos &template_param_infos) +{ + ASTContext *ast = getASTContext(); + + ClassTemplateDecl *class_template_decl = NULL; + if (decl_ctx == NULL) + decl_ctx = ast->getTranslationUnitDecl(); + + IdentifierInfo &identifier_info = ast->Idents.get(class_name); + DeclarationName decl_name (&identifier_info); + + clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); + + for (NamedDecl *decl : result) + { + class_template_decl = dyn_cast<clang::ClassTemplateDecl>(decl); + if (class_template_decl) + return class_template_decl; + } + + llvm::SmallVector<NamedDecl *, 8> template_param_decls; + + TemplateParameterList *template_param_list = CreateTemplateParameterList (ast, + template_param_infos, + template_param_decls); + + CXXRecordDecl *template_cxx_decl = CXXRecordDecl::Create (*ast, + (TagDecl::TagKind)kind, + decl_ctx, // What decl context do we use here? TU? The actual decl context? + SourceLocation(), + SourceLocation(), + &identifier_info); + + for (size_t i=0, template_param_decl_count = template_param_decls.size(); + i < template_param_decl_count; + ++i) + { + template_param_decls[i]->setDeclContext (template_cxx_decl); + } + + // With templated classes, we say that a class is templated with + // specializations, but that the bare class has no functions. + //template_cxx_decl->startDefinition(); + //template_cxx_decl->completeDefinition(); + + class_template_decl = ClassTemplateDecl::Create (*ast, + decl_ctx, // What decl context do we use here? TU? The actual decl context? + SourceLocation(), + decl_name, + template_param_list, + template_cxx_decl, + NULL); + + if (class_template_decl) + { + if (access_type != eAccessNone) + class_template_decl->setAccess (ConvertAccessTypeToAccessSpecifier (access_type)); + + //if (TagDecl *ctx_tag_decl = dyn_cast<TagDecl>(decl_ctx)) + // CompleteTagDeclarationDefinition(GetTypeForDecl(ctx_tag_decl)); + + decl_ctx->addDecl (class_template_decl); + +#ifdef LLDB_CONFIGURATION_DEBUG + VerifyDecl(class_template_decl); +#endif + } + + return class_template_decl; +} + + +ClassTemplateSpecializationDecl * +ClangASTContext::CreateClassTemplateSpecializationDecl (DeclContext *decl_ctx, + ClassTemplateDecl *class_template_decl, + int kind, + const TemplateParameterInfos &template_param_infos) +{ + ASTContext *ast = getASTContext(); + ClassTemplateSpecializationDecl *class_template_specialization_decl = ClassTemplateSpecializationDecl::Create (*ast, + (TagDecl::TagKind)kind, + decl_ctx, + SourceLocation(), + SourceLocation(), + class_template_decl, + &template_param_infos.args.front(), + template_param_infos.args.size(), + NULL); + + class_template_specialization_decl->setSpecializationKind(TSK_ExplicitSpecialization); + + return class_template_specialization_decl; +} + +ClangASTType +ClangASTContext::CreateClassTemplateSpecializationType (ClassTemplateSpecializationDecl *class_template_specialization_decl) +{ + if (class_template_specialization_decl) + { + ASTContext *ast = getASTContext(); + if (ast) + return ClangASTType(ast, ast->getTagDeclType(class_template_specialization_decl).getAsOpaquePtr()); + } + return ClangASTType(); +} + +static bool +IsOperator (const char *name, OverloadedOperatorKind &op_kind) +{ + if (name == NULL || name[0] == '\0') + return false; + +#define OPERATOR_PREFIX "operator" +#define OPERATOR_PREFIX_LENGTH (sizeof (OPERATOR_PREFIX) - 1) + + const char *post_op_name = NULL; + + bool no_space = true; + + if (::strncmp(name, OPERATOR_PREFIX, OPERATOR_PREFIX_LENGTH)) + return false; + + post_op_name = name + OPERATOR_PREFIX_LENGTH; + + if (post_op_name[0] == ' ') + { + post_op_name++; + no_space = false; + } + +#undef OPERATOR_PREFIX +#undef OPERATOR_PREFIX_LENGTH + + // This is an operator, set the overloaded operator kind to invalid + // in case this is a conversion operator... + op_kind = NUM_OVERLOADED_OPERATORS; + + switch (post_op_name[0]) + { + default: + if (no_space) + return false; + break; + case 'n': + if (no_space) + return false; + if (strcmp (post_op_name, "new") == 0) + op_kind = OO_New; + else if (strcmp (post_op_name, "new[]") == 0) + op_kind = OO_Array_New; + break; + + case 'd': + if (no_space) + return false; + if (strcmp (post_op_name, "delete") == 0) + op_kind = OO_Delete; + else if (strcmp (post_op_name, "delete[]") == 0) + op_kind = OO_Array_Delete; + break; + + case '+': + if (post_op_name[1] == '\0') + op_kind = OO_Plus; + else if (post_op_name[2] == '\0') + { + if (post_op_name[1] == '=') + op_kind = OO_PlusEqual; + else if (post_op_name[1] == '+') + op_kind = OO_PlusPlus; + } + break; + + case '-': + if (post_op_name[1] == '\0') + op_kind = OO_Minus; + else if (post_op_name[2] == '\0') + { + switch (post_op_name[1]) + { + case '=': op_kind = OO_MinusEqual; break; + case '-': op_kind = OO_MinusMinus; break; + case '>': op_kind = OO_Arrow; break; + } + } + else if (post_op_name[3] == '\0') + { + if (post_op_name[2] == '*') + op_kind = OO_ArrowStar; break; + } + break; + + case '*': + if (post_op_name[1] == '\0') + op_kind = OO_Star; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_StarEqual; + break; + + case '/': + if (post_op_name[1] == '\0') + op_kind = OO_Slash; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_SlashEqual; + break; + + case '%': + if (post_op_name[1] == '\0') + op_kind = OO_Percent; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_PercentEqual; + break; + + + case '^': + if (post_op_name[1] == '\0') + op_kind = OO_Caret; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_CaretEqual; + break; + + case '&': + if (post_op_name[1] == '\0') + op_kind = OO_Amp; + else if (post_op_name[2] == '\0') + { + switch (post_op_name[1]) + { + case '=': op_kind = OO_AmpEqual; break; + case '&': op_kind = OO_AmpAmp; break; + } + } + break; + + case '|': + if (post_op_name[1] == '\0') + op_kind = OO_Pipe; + else if (post_op_name[2] == '\0') + { + switch (post_op_name[1]) + { + case '=': op_kind = OO_PipeEqual; break; + case '|': op_kind = OO_PipePipe; break; + } + } + break; + + case '~': + if (post_op_name[1] == '\0') + op_kind = OO_Tilde; + break; + + case '!': + if (post_op_name[1] == '\0') + op_kind = OO_Exclaim; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_ExclaimEqual; + break; + + case '=': + if (post_op_name[1] == '\0') + op_kind = OO_Equal; + else if (post_op_name[1] == '=' && post_op_name[2] == '\0') + op_kind = OO_EqualEqual; + break; + + case '<': + if (post_op_name[1] == '\0') + op_kind = OO_Less; + else if (post_op_name[2] == '\0') + { + switch (post_op_name[1]) + { + case '<': op_kind = OO_LessLess; break; + case '=': op_kind = OO_LessEqual; break; + } + } + else if (post_op_name[3] == '\0') + { + if (post_op_name[2] == '=') + op_kind = OO_LessLessEqual; + } + break; + + case '>': + if (post_op_name[1] == '\0') + op_kind = OO_Greater; + else if (post_op_name[2] == '\0') + { + switch (post_op_name[1]) + { + case '>': op_kind = OO_GreaterGreater; break; + case '=': op_kind = OO_GreaterEqual; break; + } + } + else if (post_op_name[1] == '>' && + post_op_name[2] == '=' && + post_op_name[3] == '\0') + { + op_kind = OO_GreaterGreaterEqual; + } + break; + + case ',': + if (post_op_name[1] == '\0') + op_kind = OO_Comma; + break; + + case '(': + if (post_op_name[1] == ')' && post_op_name[2] == '\0') + op_kind = OO_Call; + break; + + case '[': + if (post_op_name[1] == ']' && post_op_name[2] == '\0') + op_kind = OO_Subscript; + break; + } + + return true; +} + +static inline bool +check_op_param (uint32_t op_kind, bool unary, bool binary, uint32_t num_params) +{ + // Special-case call since it can take any number of operands + if(op_kind == OO_Call) + return true; + + // The parameter count doens't include "this" + if (num_params == 0) + return unary; + if (num_params == 1) + return binary; + else + return false; +} + +bool +ClangASTContext::CheckOverloadedOperatorKindParameterCount (uint32_t op_kind, uint32_t num_params) +{ + switch (op_kind) + { + default: + break; + // C++ standard allows any number of arguments to new/delete + case OO_New: + case OO_Array_New: + case OO_Delete: + case OO_Array_Delete: + return true; + } + +#define OVERLOADED_OPERATOR(Name,Spelling,Token,Unary,Binary,MemberOnly) case OO_##Name: return check_op_param (op_kind, Unary, Binary, num_params); + switch (op_kind) + { +#include "clang/Basic/OperatorKinds.def" + default: break; + } + return false; +} + +clang::AccessSpecifier +ClangASTContext::UnifyAccessSpecifiers (clang::AccessSpecifier lhs, clang::AccessSpecifier rhs) +{ + clang::AccessSpecifier ret = lhs; + + // Make the access equal to the stricter of the field and the nested field's access + switch (ret) + { + case clang::AS_none: + break; + case clang::AS_private: + break; + case clang::AS_protected: + if (rhs == AS_private) + ret = AS_private; + break; + case clang::AS_public: + ret = rhs; + break; + } + + return ret; +} + +bool +ClangASTContext::FieldIsBitfield (FieldDecl* field, uint32_t& bitfield_bit_size) +{ + return FieldIsBitfield(getASTContext(), field, bitfield_bit_size); +} + +bool +ClangASTContext::FieldIsBitfield +( + ASTContext *ast, + FieldDecl* field, + uint32_t& bitfield_bit_size +) +{ + if (ast == NULL || field == NULL) + return false; + + if (field->isBitField()) + { + Expr* bit_width_expr = field->getBitWidth(); + if (bit_width_expr) + { + llvm::APSInt bit_width_apsint; + if (bit_width_expr->isIntegerConstantExpr(bit_width_apsint, *ast)) + { + bitfield_bit_size = bit_width_apsint.getLimitedValue(UINT32_MAX); + return true; + } + } + } + return false; +} + +bool +ClangASTContext::RecordHasFields (const RecordDecl *record_decl) +{ + if (record_decl == NULL) + return false; + + if (!record_decl->field_empty()) + return true; + + // No fields, lets check this is a CXX record and check the base classes + const CXXRecordDecl *cxx_record_decl = dyn_cast<CXXRecordDecl>(record_decl); + if (cxx_record_decl) + { + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; + ++base_class) + { + const CXXRecordDecl *base_class_decl = cast<CXXRecordDecl>(base_class->getType()->getAs<RecordType>()->getDecl()); + if (RecordHasFields(base_class_decl)) + return true; + } + } + return false; +} + +#pragma mark Objective C Classes + +ClangASTType +ClangASTContext::CreateObjCClass +( + const char *name, + DeclContext *decl_ctx, + bool isForwardDecl, + bool isInternal, + ClangASTMetadata *metadata +) +{ + ASTContext *ast = getASTContext(); + assert (ast != NULL); + assert (name && name[0]); + if (decl_ctx == NULL) + decl_ctx = ast->getTranslationUnitDecl(); + + ObjCInterfaceDecl *decl = ObjCInterfaceDecl::Create (*ast, + decl_ctx, + SourceLocation(), + &ast->Idents.get(name), + NULL, + SourceLocation(), + /*isForwardDecl,*/ + isInternal); + + if (decl && metadata) + SetMetadata(ast, decl, *metadata); + + return ClangASTType (ast, ast->getObjCInterfaceType(decl)); +} + +static inline bool +BaseSpecifierIsEmpty (const CXXBaseSpecifier *b) +{ + return ClangASTContext::RecordHasFields(b->getType()->getAsCXXRecordDecl()) == false; +} + +uint32_t +ClangASTContext::GetNumBaseClasses (const CXXRecordDecl *cxx_record_decl, bool omit_empty_base_classes) +{ + uint32_t num_bases = 0; + if (cxx_record_decl) + { + if (omit_empty_base_classes) + { + CXXRecordDecl::base_class_const_iterator base_class, base_class_end; + for (base_class = cxx_record_decl->bases_begin(), base_class_end = cxx_record_decl->bases_end(); + base_class != base_class_end; + ++base_class) + { + // Skip empty base classes + if (omit_empty_base_classes) + { + if (BaseSpecifierIsEmpty (base_class)) + continue; + } + ++num_bases; + } + } + else + num_bases = cxx_record_decl->getNumBases(); + } + return num_bases; +} + + +#pragma mark Namespace Declarations + +NamespaceDecl * +ClangASTContext::GetUniqueNamespaceDeclaration (const char *name, DeclContext *decl_ctx) +{ + NamespaceDecl *namespace_decl = NULL; + ASTContext *ast = getASTContext(); + TranslationUnitDecl *translation_unit_decl = ast->getTranslationUnitDecl (); + if (decl_ctx == NULL) + decl_ctx = translation_unit_decl; + + if (name) + { + IdentifierInfo &identifier_info = ast->Idents.get(name); + DeclarationName decl_name (&identifier_info); + clang::DeclContext::lookup_result result = decl_ctx->lookup(decl_name); + for (NamedDecl *decl : result) + { + namespace_decl = dyn_cast<clang::NamespaceDecl>(decl); + if (namespace_decl) + return namespace_decl; + } + + namespace_decl = NamespaceDecl::Create(*ast, + decl_ctx, + false, + SourceLocation(), + SourceLocation(), + &identifier_info, + NULL); + + decl_ctx->addDecl (namespace_decl); + } + else + { + if (decl_ctx == translation_unit_decl) + { + namespace_decl = translation_unit_decl->getAnonymousNamespace(); + if (namespace_decl) + return namespace_decl; + + namespace_decl = NamespaceDecl::Create(*ast, + decl_ctx, + false, + SourceLocation(), + SourceLocation(), + NULL, + NULL); + translation_unit_decl->setAnonymousNamespace (namespace_decl); + translation_unit_decl->addDecl (namespace_decl); + assert (namespace_decl == translation_unit_decl->getAnonymousNamespace()); + } + else + { + NamespaceDecl *parent_namespace_decl = cast<NamespaceDecl>(decl_ctx); + if (parent_namespace_decl) + { + namespace_decl = parent_namespace_decl->getAnonymousNamespace(); + if (namespace_decl) + return namespace_decl; + namespace_decl = NamespaceDecl::Create(*ast, + decl_ctx, + false, + SourceLocation(), + SourceLocation(), + NULL, + NULL); + parent_namespace_decl->setAnonymousNamespace (namespace_decl); + parent_namespace_decl->addDecl (namespace_decl); + assert (namespace_decl == parent_namespace_decl->getAnonymousNamespace()); + } + else + { + // BAD!!! + } + } + + + if (namespace_decl) + { + // If we make it here, we are creating the anonymous namespace decl + // for the first time, so we need to do the using directive magic + // like SEMA does + UsingDirectiveDecl* using_directive_decl = UsingDirectiveDecl::Create (*ast, + decl_ctx, + SourceLocation(), + SourceLocation(), + NestedNameSpecifierLoc(), + SourceLocation(), + namespace_decl, + decl_ctx); + using_directive_decl->setImplicit(); + decl_ctx->addDecl(using_directive_decl); + } + } +#ifdef LLDB_CONFIGURATION_DEBUG + VerifyDecl(namespace_decl); +#endif + return namespace_decl; +} + + +#pragma mark Function Types + +FunctionDecl * +ClangASTContext::CreateFunctionDeclaration (DeclContext *decl_ctx, + const char *name, + const ClangASTType &function_clang_type, + int storage, + bool is_inline) +{ + FunctionDecl *func_decl = NULL; + ASTContext *ast = getASTContext(); + if (decl_ctx == NULL) + decl_ctx = ast->getTranslationUnitDecl(); + + + const bool hasWrittenPrototype = true; + const bool isConstexprSpecified = false; + + if (name && name[0]) + { + func_decl = FunctionDecl::Create (*ast, + decl_ctx, + SourceLocation(), + SourceLocation(), + DeclarationName (&ast->Idents.get(name)), + function_clang_type.GetQualType(), + NULL, + (FunctionDecl::StorageClass)storage, + is_inline, + hasWrittenPrototype, + isConstexprSpecified); + } + else + { + func_decl = FunctionDecl::Create (*ast, + decl_ctx, + SourceLocation(), + SourceLocation(), + DeclarationName (), + function_clang_type.GetQualType(), + NULL, + (FunctionDecl::StorageClass)storage, + is_inline, + hasWrittenPrototype, + isConstexprSpecified); + } + if (func_decl) + decl_ctx->addDecl (func_decl); + +#ifdef LLDB_CONFIGURATION_DEBUG + VerifyDecl(func_decl); +#endif + + return func_decl; +} + +ClangASTType +ClangASTContext::CreateFunctionType (ASTContext *ast, + const ClangASTType& result_type, + const ClangASTType *args, + unsigned num_args, + bool is_variadic, + unsigned type_quals) +{ + assert (ast != NULL); + std::vector<QualType> qual_type_args; + for (unsigned i=0; i<num_args; ++i) + qual_type_args.push_back (args[i].GetQualType()); + + // TODO: Detect calling convention in DWARF? + FunctionProtoType::ExtProtoInfo proto_info; + proto_info.Variadic = is_variadic; + proto_info.ExceptionSpecType = EST_None; + proto_info.TypeQuals = type_quals; + proto_info.RefQualifier = RQ_None; + proto_info.NumExceptions = 0; + proto_info.Exceptions = NULL; + + return ClangASTType (ast, ast->getFunctionType (result_type.GetQualType(), + qual_type_args, + proto_info).getAsOpaquePtr()); +} + +ParmVarDecl * +ClangASTContext::CreateParameterDeclaration (const char *name, const ClangASTType ¶m_type, int storage) +{ + ASTContext *ast = getASTContext(); + assert (ast != NULL); + return ParmVarDecl::Create(*ast, + ast->getTranslationUnitDecl(), + SourceLocation(), + SourceLocation(), + name && name[0] ? &ast->Idents.get(name) : NULL, + param_type.GetQualType(), + NULL, + (VarDecl::StorageClass)storage, + 0); +} + +void +ClangASTContext::SetFunctionParameters (FunctionDecl *function_decl, ParmVarDecl **params, unsigned num_params) +{ + if (function_decl) + function_decl->setParams (ArrayRef<ParmVarDecl*>(params, num_params)); +} + + +#pragma mark Array Types + +ClangASTType +ClangASTContext::CreateArrayType (const ClangASTType &element_type, + size_t element_count, + bool is_vector) +{ + if (element_type.IsValid()) + { + ASTContext *ast = getASTContext(); + assert (ast != NULL); + + if (is_vector) + { + return ClangASTType (ast, ast->getExtVectorType(element_type.GetQualType(), element_count).getAsOpaquePtr()); + } + else + { + + llvm::APInt ap_element_count (64, element_count); + if (element_count == 0) + { + return ClangASTType (ast, ast->getIncompleteArrayType (element_type.GetQualType(), + ArrayType::Normal, + 0).getAsOpaquePtr()); + } + else + { + return ClangASTType (ast, ast->getConstantArrayType (element_type.GetQualType(), + ap_element_count, + ArrayType::Normal, + 0).getAsOpaquePtr()); + } + } + } + return ClangASTType(); +} + + + +#pragma mark Enumeration Types + +ClangASTType +ClangASTContext::CreateEnumerationType +( + const char *name, + DeclContext *decl_ctx, + const Declaration &decl, + const ClangASTType &integer_clang_type +) +{ + // TODO: Do something intelligent with the Declaration object passed in + // like maybe filling in the SourceLocation with it... + ASTContext *ast = getASTContext(); + + // TODO: ask about these... +// const bool IsScoped = false; +// const bool IsFixed = false; + + EnumDecl *enum_decl = EnumDecl::Create (*ast, + decl_ctx, + SourceLocation(), + SourceLocation(), + name && name[0] ? &ast->Idents.get(name) : NULL, + NULL, + false, // IsScoped + false, // IsScopedUsingClassTag + false); // IsFixed + + + if (enum_decl) + { + // TODO: check if we should be setting the promotion type too? + enum_decl->setIntegerType(integer_clang_type.GetQualType()); + + enum_decl->setAccess(AS_public); // TODO respect what's in the debug info + + return ClangASTType (ast, ast->getTagDeclType(enum_decl).getAsOpaquePtr()); + } + return ClangASTType(); +} + +// Disable this for now since I can't seem to get a nicely formatted float +// out of the APFloat class without just getting the float, double or quad +// and then using a formatted print on it which defeats the purpose. We ideally +// would like to get perfect string values for any kind of float semantics +// so we can support remote targets. The code below also requires a patch to +// llvm::APInt. +//bool +//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) +//{ +// uint32_t count = 0; +// bool is_complex = false; +// if (ClangASTContext::IsFloatingPointType (clang_type, count, is_complex)) +// { +// unsigned num_bytes_per_float = byte_size / count; +// unsigned num_bits_per_float = num_bytes_per_float * 8; +// +// float_str.clear(); +// uint32_t i; +// for (i=0; i<count; i++) +// { +// APInt ap_int(num_bits_per_float, bytes + i * num_bytes_per_float, (APInt::ByteOrder)apint_byte_order); +// bool is_ieee = false; +// APFloat ap_float(ap_int, is_ieee); +// char s[1024]; +// unsigned int hex_digits = 0; +// bool upper_case = false; +// +// if (ap_float.convertToHexString(s, hex_digits, upper_case, APFloat::rmNearestTiesToEven) > 0) +// { +// if (i > 0) +// float_str.append(", "); +// float_str.append(s); +// if (i == 1 && is_complex) +// float_str.append(1, 'i'); +// } +// } +// return !float_str.empty(); +// } +// return false; +//} + + +ClangASTType +ClangASTContext::GetFloatTypeFromBitSize (clang::ASTContext *ast, + size_t bit_size) +{ + if (ast) + { + if (bit_size == ast->getTypeSize(ast->FloatTy)) + return ClangASTType(ast, ast->FloatTy.getAsOpaquePtr()); + else if (bit_size == ast->getTypeSize(ast->DoubleTy)) + return ClangASTType(ast, ast->DoubleTy.getAsOpaquePtr()); + else if (bit_size == ast->getTypeSize(ast->LongDoubleTy)) + return ClangASTType(ast, ast->LongDoubleTy.getAsOpaquePtr()); + else if (bit_size == ast->getTypeSize(ast->HalfTy)) + return ClangASTType(ast, ast->HalfTy.getAsOpaquePtr()); + } + return ClangASTType(); +} + +bool +ClangASTContext::GetCompleteDecl (clang::ASTContext *ast, + clang::Decl *decl) +{ + if (!decl) + return false; + + ExternalASTSource *ast_source = ast->getExternalSource(); + + if (!ast_source) + return false; + + if (clang::TagDecl *tag_decl = llvm::dyn_cast<clang::TagDecl>(decl)) + { + if (tag_decl->isCompleteDefinition()) + return true; + + if (!tag_decl->hasExternalLexicalStorage()) + return false; + + ast_source->CompleteType(tag_decl); + + return !tag_decl->getTypeForDecl()->isIncompleteType(); + } + else if (clang::ObjCInterfaceDecl *objc_interface_decl = llvm::dyn_cast<clang::ObjCInterfaceDecl>(decl)) + { + if (objc_interface_decl->getDefinition()) + return true; + + if (!objc_interface_decl->hasExternalLexicalStorage()) + return false; + + ast_source->CompleteType(objc_interface_decl); + + return !objc_interface_decl->getTypeForDecl()->isIncompleteType(); + } + else + { + return false; + } +} + +void +ClangASTContext::SetMetadataAsUserID (const void *object, + user_id_t user_id) +{ + ClangASTMetadata meta_data; + meta_data.SetUserID (user_id); + SetMetadata (object, meta_data); +} + +void +ClangASTContext::SetMetadata (clang::ASTContext *ast, + const void *object, + ClangASTMetadata &metadata) +{ + ClangExternalASTSourceCommon *external_source = + static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); + + if (external_source) + external_source->SetMetadata(object, metadata); +} + +ClangASTMetadata * +ClangASTContext::GetMetadata (clang::ASTContext *ast, + const void *object) +{ + ClangExternalASTSourceCommon *external_source = + static_cast<ClangExternalASTSourceCommon*>(ast->getExternalSource()); + + if (external_source && external_source->HasMetadata(object)) + return external_source->GetMetadata(object); + else + return NULL; +} + +clang::DeclContext * +ClangASTContext::GetAsDeclContext (clang::CXXMethodDecl *cxx_method_decl) +{ + return llvm::dyn_cast<clang::DeclContext>(cxx_method_decl); +} + +clang::DeclContext * +ClangASTContext::GetAsDeclContext (clang::ObjCMethodDecl *objc_method_decl) +{ + return llvm::dyn_cast<clang::DeclContext>(objc_method_decl); +} + + +bool +ClangASTContext::GetClassMethodInfoForDeclContext (clang::DeclContext *decl_ctx, + lldb::LanguageType &language, + bool &is_instance_method, + ConstString &language_object_name) +{ + language_object_name.Clear(); + language = eLanguageTypeUnknown; + is_instance_method = false; + + if (decl_ctx) + { + if (clang::CXXMethodDecl *method_decl = llvm::dyn_cast<clang::CXXMethodDecl>(decl_ctx)) + { + if (method_decl->isStatic()) + { + is_instance_method = false; + } + else + { + language_object_name.SetCString("this"); + is_instance_method = true; + } + language = eLanguageTypeC_plus_plus; + return true; + } + else if (clang::ObjCMethodDecl *method_decl = llvm::dyn_cast<clang::ObjCMethodDecl>(decl_ctx)) + { + // Both static and instance methods have a "self" object in objective C + language_object_name.SetCString("self"); + if (method_decl->isInstanceMethod()) + { + is_instance_method = true; + } + else + { + is_instance_method = false; + } + language = eLanguageTypeObjC; + return true; + } + else if (clang::FunctionDecl *function_decl = llvm::dyn_cast<clang::FunctionDecl>(decl_ctx)) + { + ClangASTMetadata *metadata = GetMetadata (&decl_ctx->getParentASTContext(), function_decl); + if (metadata && metadata->HasObjectPtr()) + { + language_object_name.SetCString (metadata->GetObjectPtrName()); + language = eLanguageTypeObjC; + is_instance_method = true; + } + return true; + } + } + return false; +} + |
