maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/lldb/source/Symbol/ClangASTContext.cpp

2292 lines
84 KiB
C++
Raw Blame History

//===-- 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 &param_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;
}
Reference in New Issue View Git Blame Copy Permalink