2010-07-17 02:28:27 +08:00
//===-- ClangASTSource.cpp ---------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
2010-06-09 00:52:24 +08:00
# include "clang/AST/ASTContext.h"
2012-02-04 16:49:35 +08:00
# include "clang/AST/RecordLayout.h"
2010-10-15 11:36:13 +08:00
# include "lldb/Core/Log.h"
2011-09-17 14:21:20 +08:00
# include "lldb/Core/Module.h"
2011-10-29 09:58:46 +08:00
# include "lldb/Core/ModuleList.h"
2011-10-29 10:28:18 +08:00
# include "lldb/Expression/ASTDumper.h"
2010-06-09 00:52:24 +08:00
# include "lldb/Expression/ClangASTSource.h"
# include "lldb/Expression/ClangExpression.h"
2011-10-29 09:58:46 +08:00
# include "lldb/Symbol/ClangNamespaceDecl.h"
# include "lldb/Symbol/SymbolVendor.h"
2011-12-01 06:11:59 +08:00
# include "lldb/Target/ObjCLanguageRuntime.h"
2011-10-29 09:58:46 +08:00
# include "lldb/Target/Target.h"
2010-06-09 00:52:24 +08:00
using namespace clang ;
using namespace lldb_private ;
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
ClangASTSource : : ~ ClangASTSource ( )
{
2011-11-29 08:42:02 +08:00
m_ast_importer - > ForgetDestination ( m_ast_context ) ;
2011-12-01 07:18:53 +08:00
// We are in the process of destruction, don't create clang ast context on demand
// by passing false to Target::GetScratchClangASTContext(create_on_demand).
ClangASTContext * scratch_clang_ast_context = m_target - > GetScratchClangASTContext ( false ) ;
2011-11-29 08:42:02 +08:00
if ( ! scratch_clang_ast_context )
return ;
clang : : ASTContext * scratch_ast_context = scratch_clang_ast_context - > getASTContext ( ) ;
if ( ! scratch_ast_context )
return ;
if ( m_ast_context ! = scratch_ast_context )
m_ast_importer - > ForgetSource ( scratch_ast_context , m_ast_context ) ;
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
}
2010-06-09 00:52:24 +08:00
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
void
ClangASTSource : : StartTranslationUnit ( ASTConsumer * Consumer )
{
2011-10-29 07:38:38 +08:00
if ( ! m_ast_context )
return ;
m_ast_context - > getTranslationUnitDecl ( ) - > setHasExternalVisibleStorage ( ) ;
m_ast_context - > getTranslationUnitDecl ( ) - > setHasExternalLexicalStorage ( ) ;
2010-06-09 00:52:24 +08:00
}
// The core lookup interface.
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
DeclContext : : lookup_result
ClangASTSource : : FindExternalVisibleDeclsByName
2010-10-15 11:36:13 +08:00
(
const DeclContext * decl_ctx ,
2010-10-16 06:48:33 +08:00
DeclarationName clang_decl_name
2010-10-15 11:36:13 +08:00
)
{
2011-10-29 07:38:38 +08:00
if ( ! m_ast_context )
return SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
if ( GetImportInProgress ( ) )
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
return SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
std : : string decl_name ( clang_decl_name . getAsString ( ) ) ;
// if (m_decl_map.DoingASTImport ())
// return DeclContext::lookup_result();
//
2010-10-16 06:48:33 +08:00
switch ( clang_decl_name . getNameKind ( ) ) {
2010-06-09 00:52:24 +08:00
// Normal identifiers.
case DeclarationName : : Identifier :
2010-10-16 06:48:33 +08:00
if ( clang_decl_name . getAsIdentifierInfo ( ) - > getBuiltinID ( ) ! = 0 )
return SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
break ;
2010-06-09 00:52:24 +08:00
// Operator names. Not important for now.
case DeclarationName : : CXXOperatorName :
case DeclarationName : : CXXLiteralOperatorName :
return DeclContext : : lookup_result ( ) ;
// Using directives found in this context.
// Tell Sema we didn't find any or we'll end up getting asked a *lot*.
case DeclarationName : : CXXUsingDirective :
2010-10-16 06:48:33 +08:00
return SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
2010-06-09 00:52:24 +08:00
case DeclarationName : : ObjCZeroArgSelector :
case DeclarationName : : ObjCOneArgSelector :
case DeclarationName : : ObjCMultiArgSelector :
2011-11-10 03:33:21 +08:00
{
llvm : : SmallVector < NamedDecl * , 1 > method_decls ;
2010-06-09 00:52:24 +08:00
2011-11-10 03:33:21 +08:00
NameSearchContext method_search_context ( * this , method_decls , clang_decl_name , decl_ctx ) ;
FindObjCMethodDecls ( method_search_context ) ;
return SetExternalVisibleDeclsForName ( decl_ctx , clang_decl_name , method_decls ) ;
}
2010-06-09 00:52:24 +08:00
// These aren't possible in the global context.
case DeclarationName : : CXXConstructorName :
case DeclarationName : : CXXDestructorName :
case DeclarationName : : CXXConversionFunctionName :
return DeclContext : : lookup_result ( ) ;
}
2010-10-15 11:36:13 +08:00
2011-10-29 07:38:38 +08:00
if ( ! GetLookupsEnabled ( ) )
2010-10-16 06:48:33 +08:00
{
// Wait until we see a '$' at the start of a name before we start doing
// any lookups so we can avoid lookup up all of the builtin types.
if ( ! decl_name . empty ( ) & & decl_name [ 0 ] = = ' $ ' )
{
2011-10-29 07:38:38 +08:00
SetLookupsEnabled ( true ) ;
2010-10-16 06:48:33 +08:00
}
else
{
return SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
}
2010-10-15 11:36:13 +08:00
}
2010-10-16 06:48:33 +08:00
2010-11-13 12:18:24 +08:00
ConstString const_decl_name ( decl_name . c_str ( ) ) ;
2010-06-09 00:52:24 +08:00
2010-11-13 12:18:24 +08:00
const char * uniqued_const_decl_name = const_decl_name . GetCString ( ) ;
if ( m_active_lookups . find ( uniqued_const_decl_name ) ! = m_active_lookups . end ( ) )
{
// We are currently looking up this name...
return DeclContext : : lookup_result ( ) ;
}
m_active_lookups . insert ( uniqued_const_decl_name ) ;
2010-11-15 09:34:18 +08:00
// static uint32_t g_depth = 0;
// ++g_depth;
// printf("[%5u] FindExternalVisibleDeclsByName() \"%s\"\n", g_depth, uniqued_const_decl_name);
2010-11-13 12:18:24 +08:00
llvm : : SmallVector < NamedDecl * , 4 > name_decls ;
2010-10-16 06:48:33 +08:00
NameSearchContext name_search_context ( * this , name_decls , clang_decl_name , decl_ctx ) ;
2011-10-29 07:38:38 +08:00
FindExternalVisibleDecls ( name_search_context ) ;
2010-11-13 12:18:24 +08:00
DeclContext : : lookup_result result ( SetExternalVisibleDeclsForName ( decl_ctx , clang_decl_name , name_decls ) ) ;
2010-11-15 09:34:18 +08:00
// --g_depth;
2010-11-13 12:18:24 +08:00
m_active_lookups . erase ( uniqued_const_decl_name ) ;
return result ;
2010-06-09 00:52:24 +08:00
}
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
void
2011-10-29 07:38:38 +08:00
ClangASTSource : : CompleteType ( TagDecl * tag_decl )
2011-10-29 10:28:18 +08:00
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-12-09 07:45:45 +08:00
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
2011-10-29 10:28:18 +08:00
if ( log )
{
2012-01-14 06:05:55 +08:00
log - > Printf ( " CompleteTagDecl[%u] on (ASTContext*)%p Completing (TagDecl*)%p named %s " ,
current_id ,
2011-12-09 07:45:45 +08:00
m_ast_context ,
2012-01-14 06:05:55 +08:00
tag_decl ,
2011-12-09 07:45:45 +08:00
tag_decl - > getName ( ) . str ( ) . c_str ( ) ) ;
log - > Printf ( " CTD[%u] Before: " , current_id ) ;
2011-10-29 10:28:18 +08:00
ASTDumper dumper ( ( Decl * ) tag_decl ) ;
dumper . ToLog ( log , " [CTD] " ) ;
}
2011-12-09 07:45:45 +08:00
if ( ! m_ast_importer - > CompleteTagDecl ( tag_decl ) )
{
// We couldn't complete the type. Maybe there's a definition
// somewhere else that can be completed.
if ( log )
log - > Printf ( " CTD[%u] Type could not be completed in the module in which it was first found. " , current_id ) ;
bool found = false ;
DeclContext * decl_ctx = tag_decl - > getDeclContext ( ) ;
if ( const NamespaceDecl * namespace_context = dyn_cast < NamespaceDecl > ( decl_ctx ) )
{
ClangASTImporter : : NamespaceMapSP namespace_map = m_ast_importer - > GetNamespaceMap ( namespace_context ) ;
if ( log & & log - > GetVerbose ( ) )
log - > Printf ( " CTD[%u] Inspecting namespace map %p (%d entries) " ,
current_id ,
namespace_map . get ( ) ,
( int ) namespace_map - > size ( ) ) ;
if ( ! namespace_map )
return ;
for ( ClangASTImporter : : NamespaceMap : : iterator i = namespace_map - > begin ( ) , e = namespace_map - > end ( ) ;
i ! = e & & ! found ;
+ + i )
{
if ( log )
log - > Printf ( " CTD[%u] Searching namespace %s in module %s " ,
current_id ,
i - > second . GetNamespaceDecl ( ) - > getNameAsString ( ) . c_str ( ) ,
i - > first - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
TypeList types ;
SymbolContext null_sc ;
ConstString name ( tag_decl - > getName ( ) . str ( ) . c_str ( ) ) ;
2012-03-27 07:03:23 +08:00
i - > first - > FindTypesInNamespace ( null_sc , name , & i - > second , UINT32_MAX , types ) ;
2011-12-09 07:45:45 +08:00
for ( uint32_t ti = 0 , te = types . GetSize ( ) ;
ti ! = te & & ! found ;
+ + ti )
{
lldb : : TypeSP type = types . GetTypeAtIndex ( ti ) ;
if ( ! type )
continue ;
lldb : : clang_type_t opaque_type = type - > GetClangFullType ( ) ;
if ( ! opaque_type )
continue ;
2011-12-14 09:13:04 +08:00
const TagType * tag_type = QualType : : getFromOpaquePtr ( opaque_type ) - > getAs < TagType > ( ) ;
2011-12-09 07:45:45 +08:00
if ( ! tag_type )
continue ;
TagDecl * candidate_tag_decl = const_cast < TagDecl * > ( tag_type - > getDecl ( ) ) ;
if ( m_ast_importer - > CompleteTagDeclWithOrigin ( tag_decl , candidate_tag_decl ) )
found = true ;
}
}
}
else
{
TypeList types ;
SymbolContext null_sc ;
ConstString name ( tag_decl - > getName ( ) . str ( ) . c_str ( ) ) ;
ClangNamespaceDecl namespace_decl ;
ModuleList & module_list = m_target - > GetImages ( ) ;
2012-03-27 07:03:23 +08:00
bool exact_match = false ;
2012-04-07 01:41:13 +08:00
module_list . FindTypes ( null_sc , name , exact_match , UINT32_MAX , types ) ;
2011-12-09 07:45:45 +08:00
for ( uint32_t ti = 0 , te = types . GetSize ( ) ;
ti ! = te & & ! found ;
+ + ti )
{
lldb : : TypeSP type = types . GetTypeAtIndex ( ti ) ;
if ( ! type )
continue ;
lldb : : clang_type_t opaque_type = type - > GetClangFullType ( ) ;
if ( ! opaque_type )
continue ;
2011-12-14 09:13:04 +08:00
const TagType * tag_type = QualType : : getFromOpaquePtr ( opaque_type ) - > getAs < TagType > ( ) ;
2011-12-09 07:45:45 +08:00
if ( ! tag_type )
continue ;
TagDecl * candidate_tag_decl = const_cast < TagDecl * > ( tag_type - > getDecl ( ) ) ;
if ( m_ast_importer - > CompleteTagDeclWithOrigin ( tag_decl , candidate_tag_decl ) )
found = true ;
}
}
}
2011-10-29 10:28:18 +08:00
if ( log )
{
log - > Printf ( " [CTD] After: " ) ;
ASTDumper dumper ( ( Decl * ) tag_decl ) ;
dumper . ToLog ( log , " [CTD] " ) ;
}
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
}
2011-10-29 07:38:38 +08:00
void
2011-10-29 10:28:18 +08:00
ClangASTSource : : CompleteType ( clang : : ObjCInterfaceDecl * interface_decl )
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
if ( log )
{
2011-11-18 11:28:09 +08:00
log - > Printf ( " [CompleteObjCInterfaceDecl] on (ASTContext*)%p Completing an ObjCInterfaceDecl named %s " , m_ast_context , interface_decl - > getName ( ) . str ( ) . c_str ( ) ) ;
2011-10-29 10:28:18 +08:00
log - > Printf ( " [COID] Before: " ) ;
ASTDumper dumper ( ( Decl * ) interface_decl ) ;
dumper . ToLog ( log , " [COID] " ) ;
}
m_ast_importer - > CompleteObjCInterfaceDecl ( interface_decl ) ;
if ( log )
{
log - > Printf ( " [COID] After: " ) ;
ASTDumper dumper ( ( Decl * ) interface_decl ) ;
dumper . ToLog ( log , " [COID] " ) ;
}
2010-09-23 11:01:22 +08:00
}
2011-07-30 10:42:06 +08:00
clang : : ExternalLoadResult
2011-10-29 10:28:18 +08:00
ClangASTSource : : FindExternalLexicalDecls ( const DeclContext * decl_context ,
bool ( * predicate ) ( Decl : : Kind ) ,
llvm : : SmallVectorImpl < Decl * > & decls )
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
const Decl * context_decl = dyn_cast < Decl > ( decl_context ) ;
if ( ! context_decl )
return ELR_Failure ;
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
if ( log )
{
if ( const NamedDecl * context_named_decl = dyn_cast < NamedDecl > ( context_decl ) )
2011-11-18 11:28:09 +08:00
log - > Printf ( " FindExternalLexicalDecls[%u] on (ASTContext*)%p in '%s' (%sDecl*)%p with %s predicate " ,
2011-10-29 10:28:18 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2011-10-29 10:28:18 +08:00
context_named_decl - > getNameAsString ( ) . c_str ( ) ,
2011-11-18 11:28:09 +08:00
context_decl - > getDeclKindName ( ) ,
context_decl ,
2011-10-29 10:28:18 +08:00
( predicate ? " non-null " : " null " ) ) ;
else if ( context_decl )
2011-11-18 11:28:09 +08:00
log - > Printf ( " FindExternalLexicalDecls[%u] on (ASTContext*)%p in (%sDecl*)%p with %s predicate " ,
2011-10-29 10:28:18 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2011-10-29 10:28:18 +08:00
context_decl - > getDeclKindName ( ) ,
2011-11-18 11:28:09 +08:00
context_decl ,
2011-10-29 10:28:18 +08:00
( predicate ? " non-null " : " null " ) ) ;
else
2011-11-18 11:28:09 +08:00
log - > Printf ( " FindExternalLexicalDecls[%u] on (ASTContext*)%p in a NULL context with %s predicate " ,
2011-10-29 10:28:18 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2011-10-29 10:28:18 +08:00
( predicate ? " non-null " : " null " ) ) ;
}
Decl * original_decl = NULL ;
ASTContext * original_ctx = NULL ;
if ( ! m_ast_importer - > ResolveDeclOrigin ( context_decl , & original_decl , & original_ctx ) )
return ELR_Failure ;
if ( log )
{
2012-01-14 06:05:55 +08:00
log - > Printf ( " FELD[%u] Original decl (Decl*)%p: " , current_id , original_decl ) ;
2011-10-29 10:28:18 +08:00
ASTDumper ( original_decl ) . ToLog ( log , " " ) ;
}
if ( TagDecl * original_tag_decl = dyn_cast < TagDecl > ( original_decl ) )
{
ExternalASTSource * external_source = original_ctx - > getExternalSource ( ) ;
if ( external_source )
external_source - > CompleteType ( original_tag_decl ) ;
}
2011-12-09 07:45:45 +08:00
const DeclContext * original_decl_context = dyn_cast < DeclContext > ( original_decl ) ;
2011-10-29 10:28:18 +08:00
if ( ! original_decl_context )
return ELR_Failure ;
for ( TagDecl : : decl_iterator iter = original_decl_context - > decls_begin ( ) ;
iter ! = original_decl_context - > decls_end ( ) ;
+ + iter )
{
Decl * decl = * iter ;
if ( ! predicate | | predicate ( decl - > getKind ( ) ) )
{
if ( log )
{
ASTDumper ast_dumper ( decl ) ;
if ( const NamedDecl * context_named_decl = dyn_cast < NamedDecl > ( context_decl ) )
log - > Printf ( " FELD[%d] Adding [to %s] lexical decl %s " , current_id , context_named_decl - > getNameAsString ( ) . c_str ( ) , ast_dumper . GetCString ( ) ) ;
else
log - > Printf ( " FELD[%d] Adding lexical decl %s " , current_id , ast_dumper . GetCString ( ) ) ;
}
2011-11-17 02:20:47 +08:00
Decl * copied_decl = m_ast_importer - > CopyDecl ( m_ast_context , original_ctx , decl ) ;
2011-10-29 10:28:18 +08:00
2012-03-21 05:11:12 +08:00
if ( ! copied_decl )
continue ;
2012-03-15 09:53:17 +08:00
if ( FieldDecl * copied_field = dyn_cast < FieldDecl > ( copied_decl ) )
{
QualType copied_field_type = copied_field - > getType ( ) ;
if ( const TagType * copied_field_tag_type = copied_field_type - > getAs < TagType > ( ) )
m_ast_importer - > CompleteTagDecl ( copied_field_tag_type - > getDecl ( ) ) ;
if ( const ObjCObjectType * copied_field_object_type = copied_field_type - > getAs < ObjCObjectType > ( ) )
if ( ObjCInterfaceDecl * copied_field_objc_interface_decl = copied_field_object_type - > getInterface ( ) )
m_ast_importer - > CompleteObjCInterfaceDecl ( copied_field_objc_interface_decl ) ;
}
2011-10-29 10:28:18 +08:00
decls . push_back ( copied_decl ) ;
}
}
return ELR_AlreadyLoaded ;
2010-06-09 00:52:24 +08:00
}
2011-10-30 03:50:43 +08:00
void
ClangASTSource : : FindExternalVisibleDecls ( NameSearchContext & context )
{
assert ( m_ast_context ) ;
const ConstString name ( context . m_decl_name . getAsString ( ) . c_str ( ) ) ;
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
if ( log )
{
if ( ! context . m_decl_context )
2012-01-14 06:05:55 +08:00
log - > Printf ( " ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in a NULL DeclContext " , current_id , m_ast_context , name . GetCString ( ) ) ;
2011-10-30 03:50:43 +08:00
else if ( const NamedDecl * context_named_decl = dyn_cast < NamedDecl > ( context . m_decl_context ) )
2011-11-18 11:28:09 +08:00
log - > Printf ( " ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in '%s' " , current_id , m_ast_context , name . GetCString ( ) , context_named_decl - > getNameAsString ( ) . c_str ( ) ) ;
2011-10-30 03:50:43 +08:00
else
2011-11-18 11:28:09 +08:00
log - > Printf ( " ClangASTSource::FindExternalVisibleDecls[%u] on (ASTContext*)%p for '%s' in a '%s' " , current_id , m_ast_context , name . GetCString ( ) , context . m_decl_context - > getDeclKindName ( ) ) ;
2011-10-30 03:50:43 +08:00
}
context . m_namespace_map . reset ( new ClangASTImporter : : NamespaceMap ) ;
if ( const NamespaceDecl * namespace_context = dyn_cast < NamespaceDecl > ( context . m_decl_context ) )
{
ClangASTImporter : : NamespaceMapSP namespace_map = m_ast_importer - > GetNamespaceMap ( namespace_context ) ;
if ( log & & log - > GetVerbose ( ) )
log - > Printf ( " CAS::FEVD[%u] Inspecting namespace map %p (%d entries) " ,
current_id ,
namespace_map . get ( ) ,
( int ) namespace_map - > size ( ) ) ;
if ( ! namespace_map )
return ;
for ( ClangASTImporter : : NamespaceMap : : iterator i = namespace_map - > begin ( ) , e = namespace_map - > end ( ) ;
i ! = e ;
+ + i )
{
if ( log )
log - > Printf ( " CAS::FEVD[%u] Searching namespace %s in module %s " ,
current_id ,
i - > second . GetNamespaceDecl ( ) - > getNameAsString ( ) . c_str ( ) ,
i - > first - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
FindExternalVisibleDecls ( context ,
i - > first ,
i - > second ,
current_id ) ;
}
}
2011-11-16 05:50:18 +08:00
else if ( isa < ObjCInterfaceDecl > ( context . m_decl_context ) )
2011-11-15 10:11:17 +08:00
{
2012-02-04 16:49:35 +08:00
FindObjCPropertyAndIvarDecls ( context ) ;
2011-11-15 10:11:17 +08:00
}
2011-10-30 03:50:43 +08:00
else if ( ! isa < TranslationUnitDecl > ( context . m_decl_context ) )
{
// we shouldn't be getting FindExternalVisibleDecls calls for these
return ;
}
else
{
ClangNamespaceDecl namespace_decl ;
if ( log )
log - > Printf ( " CAS::FEVD[%u] Searching the root namespace " , current_id ) ;
FindExternalVisibleDecls ( context ,
lldb : : ModuleSP ( ) ,
namespace_decl ,
current_id ) ;
}
if ( ! context . m_namespace_map - > empty ( ) )
{
if ( log & & log - > GetVerbose ( ) )
log - > Printf ( " CAS::FEVD[%u] Registering namespace map %p (%d entries) " ,
current_id ,
context . m_namespace_map . get ( ) ,
( int ) context . m_namespace_map - > size ( ) ) ;
NamespaceDecl * clang_namespace_decl = AddNamespace ( context , context . m_namespace_map ) ;
if ( clang_namespace_decl )
clang_namespace_decl - > setHasExternalVisibleStorage ( ) ;
}
}
void
ClangASTSource : : FindExternalVisibleDecls ( NameSearchContext & context ,
lldb : : ModuleSP module_sp ,
ClangNamespaceDecl & namespace_decl ,
unsigned int current_id )
{
assert ( m_ast_context ) ;
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
SymbolContextList sc_list ;
const ConstString name ( context . m_decl_name . getAsString ( ) . c_str ( ) ) ;
const char * name_unique_cstr = name . GetCString ( ) ;
2012-02-04 16:49:35 +08:00
static ConstString id_name ( " id " ) ;
static ConstString Class_name ( " Class " ) ;
if ( name = = id_name | | name = = Class_name )
return ;
2011-10-30 03:50:43 +08:00
if ( name_unique_cstr = = NULL )
return ;
// The ClangASTSource is not responsible for finding $-names.
if ( name_unique_cstr [ 0 ] = = ' $ ' )
return ;
if ( module_sp & & namespace_decl )
{
ClangNamespaceDecl found_namespace_decl ;
SymbolVendor * symbol_vendor = module_sp - > GetSymbolVendor ( ) ;
if ( symbol_vendor )
{
SymbolContext null_sc ;
found_namespace_decl = symbol_vendor - > FindNamespace ( null_sc , name , & namespace_decl ) ;
if ( found_namespace_decl )
{
context . m_namespace_map - > push_back ( std : : pair < lldb : : ModuleSP , ClangNamespaceDecl > ( module_sp , found_namespace_decl ) ) ;
if ( log )
log - > Printf ( " CAS::FEVD[%u] Found namespace %s in module %s " ,
current_id ,
name . GetCString ( ) ,
module_sp - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
}
}
}
else
{
ModuleList & images = m_target - > GetImages ( ) ;
for ( uint32_t i = 0 , e = images . GetSize ( ) ;
i ! = e ;
+ + i )
{
lldb : : ModuleSP image = images . GetModuleAtIndex ( i ) ;
if ( ! image )
continue ;
ClangNamespaceDecl found_namespace_decl ;
SymbolVendor * symbol_vendor = image - > GetSymbolVendor ( ) ;
if ( ! symbol_vendor )
continue ;
SymbolContext null_sc ;
found_namespace_decl = symbol_vendor - > FindNamespace ( null_sc , name , & namespace_decl ) ;
if ( found_namespace_decl )
{
context . m_namespace_map - > push_back ( std : : pair < lldb : : ModuleSP , ClangNamespaceDecl > ( image , found_namespace_decl ) ) ;
if ( log )
log - > Printf ( " CAS::FEVD[%u] Found namespace %s in module %s " ,
current_id ,
name . GetCString ( ) ,
image - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
}
}
}
do
{
TypeList types ;
SymbolContext null_sc ;
2012-03-27 07:03:23 +08:00
const bool exact_match = false ;
2011-12-20 03:38:39 +08:00
2011-10-30 03:50:43 +08:00
if ( module_sp & & namespace_decl )
2012-03-27 07:03:23 +08:00
module_sp - > FindTypesInNamespace ( null_sc , name , & namespace_decl , 1 , types ) ;
2011-12-20 03:38:39 +08:00
else
2012-04-07 01:41:13 +08:00
m_target - > GetImages ( ) . FindTypes ( null_sc , name , exact_match , 1 , types ) ;
2011-10-30 03:50:43 +08:00
if ( types . GetSize ( ) )
{
lldb : : TypeSP type_sp = types . GetTypeAtIndex ( 0 ) ;
if ( log )
{
const char * name_string = type_sp - > GetName ( ) . GetCString ( ) ;
log - > Printf ( " CAS::FEVD[%u] Matching type found for \" %s \" : %s " ,
current_id ,
name . GetCString ( ) ,
( name_string ? name_string : " <anonymous> " ) ) ;
}
2011-12-06 11:41:14 +08:00
2011-10-30 03:50:43 +08:00
void * copied_type = GuardedCopyType ( m_ast_context , type_sp - > GetClangAST ( ) , type_sp - > GetClangFullType ( ) ) ;
2011-12-06 11:41:14 +08:00
2011-12-02 05:04:37 +08:00
if ( ! copied_type )
{
if ( log )
2011-12-06 11:41:14 +08:00
log - > Printf ( " CAS::FEVD[%u] - Couldn't export the type for a constant integer result " ,
current_id ) ;
2011-12-02 05:04:37 +08:00
break ;
}
2011-10-30 03:50:43 +08:00
context . AddTypeDecl ( copied_type ) ;
}
2011-12-01 06:11:59 +08:00
2011-10-30 03:50:43 +08:00
} while ( 0 ) ;
}
2011-11-10 03:33:21 +08:00
void
ClangASTSource : : FindObjCMethodDecls ( NameSearchContext & context )
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-11-12 04:37:26 +08:00
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
2011-11-10 03:33:21 +08:00
const DeclarationName & decl_name ( context . m_decl_name ) ;
const DeclContext * decl_ctx ( context . m_decl_context ) ;
const ObjCInterfaceDecl * interface_decl = dyn_cast < ObjCInterfaceDecl > ( decl_ctx ) ;
if ( ! interface_decl )
return ;
2012-04-05 08:12:52 +08:00
do
{
Decl * original_decl = NULL ;
ASTContext * original_ctx = NULL ;
m_ast_importer - > ResolveDeclOrigin ( interface_decl , & original_decl , & original_ctx ) ;
if ( ! original_decl )
break ;
ObjCInterfaceDecl * original_interface_decl = dyn_cast < ObjCInterfaceDecl > ( original_decl ) ;
Selector original_selector ;
if ( decl_name . isObjCZeroArgSelector ( ) )
{
IdentifierInfo * ident = & original_ctx - > Idents . get ( decl_name . getAsString ( ) ) ;
original_selector = original_ctx - > Selectors . getSelector ( 0 , & ident ) ;
}
else if ( decl_name . isObjCOneArgSelector ( ) )
{
const std : : string & decl_name_string = decl_name . getAsString ( ) ;
std : : string decl_name_string_without_colon ( decl_name_string . c_str ( ) , decl_name_string . length ( ) - 1 ) ;
IdentifierInfo * ident = & original_ctx - > Idents . get ( decl_name_string_without_colon . c_str ( ) ) ;
original_selector = original_ctx - > Selectors . getSelector ( 1 , & ident ) ;
}
else
{
SmallVector < IdentifierInfo * , 4 > idents ;
clang : : Selector sel = decl_name . getObjCSelector ( ) ;
int num_args = sel . getNumArgs ( ) ;
for ( unsigned i = 0 ;
i ! = num_args ;
+ + i )
{
idents . push_back ( & original_ctx - > Idents . get ( sel . getNameForSlot ( i ) ) ) ;
}
original_selector = original_ctx - > Selectors . getSelector ( num_args , idents . data ( ) ) ;
}
DeclarationName original_decl_name ( original_selector ) ;
ObjCInterfaceDecl : : lookup_result result = original_interface_decl - > lookup ( original_decl_name ) ;
if ( result . first = = result . second )
break ;
if ( ! * result . first )
break ;
ObjCMethodDecl * result_method = dyn_cast < ObjCMethodDecl > ( * result . first ) ;
if ( ! result_method )
break ;
Decl * copied_decl = m_ast_importer - > CopyDecl ( m_ast_context , & result_method - > getASTContext ( ) , result_method ) ;
if ( ! copied_decl )
continue ;
ObjCMethodDecl * copied_method_decl = dyn_cast < ObjCMethodDecl > ( copied_decl ) ;
if ( ! copied_method_decl )
continue ;
if ( log )
{
ASTDumper dumper ( ( Decl * ) copied_method_decl ) ;
log - > Printf ( " CAS::FOMD[%d] found (in debug info) %s " , current_id , dumper . GetCString ( ) ) ;
}
context . AddNamedDecl ( copied_method_decl ) ;
return ;
} while ( 0 ) ;
2011-11-10 03:33:21 +08:00
StreamString ss ;
2011-12-06 11:41:14 +08:00
2011-11-10 03:33:21 +08:00
if ( decl_name . isObjCZeroArgSelector ( ) )
{
ss . Printf ( " %s " , decl_name . getAsString ( ) . c_str ( ) ) ;
}
else if ( decl_name . isObjCOneArgSelector ( ) )
{
2011-11-15 02:29:46 +08:00
ss . Printf ( " %s " , decl_name . getAsString ( ) . c_str ( ) ) ;
2011-11-10 03:33:21 +08:00
}
else
{
clang : : Selector sel = decl_name . getObjCSelector ( ) ;
for ( unsigned i = 0 , e = sel . getNumArgs ( ) ;
i ! = e ;
+ + i )
{
llvm : : StringRef r = sel . getNameForSlot ( i ) ;
ss . Printf ( " %s: " , r . str ( ) . c_str ( ) ) ;
}
}
ss . Flush ( ) ;
2011-11-12 04:37:26 +08:00
ConstString selector_name ( ss . GetData ( ) ) ;
2011-11-10 03:33:21 +08:00
if ( log )
2011-11-18 11:28:09 +08:00
log - > Printf ( " ClangASTSource::FindObjCMethodDecls[%d] on (ASTContext*)%p for selector [%s %s] " ,
current_id ,
m_ast_context ,
2011-11-12 04:37:26 +08:00
interface_decl - > getNameAsString ( ) . c_str ( ) ,
selector_name . AsCString ( ) ) ;
2012-01-19 10:17:40 +08:00
SymbolContextList sc_list ;
const bool include_symbols = false ;
2012-02-11 06:52:19 +08:00
const bool include_inlines = false ;
2012-01-19 10:17:40 +08:00
const bool append = false ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
std : : string interface_name = interface_decl - > getNameAsString ( ) ;
do
2011-12-06 11:41:14 +08:00
{
2012-01-19 10:17:40 +08:00
StreamString ms ;
ms . Printf ( " -[%s %s] " , interface_name . c_str ( ) , selector_name . AsCString ( ) ) ;
ms . Flush ( ) ;
ConstString instance_method_name ( ms . GetData ( ) ) ;
2012-02-11 06:52:19 +08:00
m_target - > GetImages ( ) . FindFunctions ( instance_method_name , lldb : : eFunctionNameTypeFull , include_symbols , include_inlines , append , sc_list ) ;
2012-01-19 10:17:40 +08:00
if ( sc_list . GetSize ( ) )
break ;
ms . Clear ( ) ;
ms . Printf ( " +[%s %s] " , interface_name . c_str ( ) , selector_name . AsCString ( ) ) ;
ms . Flush ( ) ;
ConstString class_method_name ( ms . GetData ( ) ) ;
2012-02-11 06:52:19 +08:00
m_target - > GetImages ( ) . FindFunctions ( class_method_name , lldb : : eFunctionNameTypeFull , include_symbols , include_inlines , append , sc_list ) ;
2012-01-19 10:17:40 +08:00
if ( sc_list . GetSize ( ) )
break ;
// Fall back and check for methods in categories. If we find methods this way, we need to check that they're actually in
// categories on the desired class.
SymbolContextList candidate_sc_list ;
2012-02-11 06:52:19 +08:00
m_target - > GetImages ( ) . FindFunctions ( selector_name , lldb : : eFunctionNameTypeSelector , include_symbols , include_inlines , append , candidate_sc_list ) ;
2012-01-19 10:17:40 +08:00
for ( uint32_t ci = 0 , ce = candidate_sc_list . GetSize ( ) ;
ci ! = ce ;
+ + ci )
2011-12-06 11:41:14 +08:00
{
2012-01-19 10:17:40 +08:00
SymbolContext candidate_sc ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
if ( ! candidate_sc_list . GetContextAtIndex ( ci , candidate_sc ) )
2011-12-06 11:41:14 +08:00
continue ;
2012-01-19 10:17:40 +08:00
if ( ! candidate_sc . function )
2011-12-06 11:41:14 +08:00
continue ;
2012-01-19 10:17:40 +08:00
const char * candidate_name = candidate_sc . function - > GetName ( ) . AsCString ( ) ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
const char * cursor = candidate_name ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
if ( * cursor ! = ' + ' & & * cursor ! = ' - ' )
2011-12-06 11:41:14 +08:00
continue ;
2012-01-19 10:17:40 +08:00
+ + cursor ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
if ( * cursor ! = ' [ ' )
2011-12-06 11:41:14 +08:00
continue ;
2012-01-19 10:17:40 +08:00
+ + cursor ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
size_t interface_len = interface_name . length ( ) ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
if ( strncmp ( cursor , interface_name . c_str ( ) , interface_len ) )
2011-12-06 11:41:14 +08:00
continue ;
2012-01-19 10:17:40 +08:00
cursor + = interface_len ;
2011-12-06 11:41:14 +08:00
2012-01-19 10:17:40 +08:00
if ( * cursor = = ' ' | | * cursor = = ' ( ' )
sc_list . Append ( candidate_sc ) ;
2011-12-06 11:41:14 +08:00
}
}
2012-01-19 10:17:40 +08:00
while ( 0 ) ;
2011-11-12 04:37:26 +08:00
for ( uint32_t i = 0 , e = sc_list . GetSize ( ) ;
i ! = e ;
+ + i )
{
SymbolContext sc ;
if ( ! sc_list . GetContextAtIndex ( i , sc ) )
continue ;
if ( ! sc . function )
continue ;
DeclContext * function_ctx = sc . function - > GetClangDeclContext ( ) ;
if ( ! function_ctx )
continue ;
ObjCMethodDecl * method_decl = dyn_cast < ObjCMethodDecl > ( function_ctx ) ;
if ( ! method_decl )
continue ;
ObjCInterfaceDecl * found_interface_decl = method_decl - > getClassInterface ( ) ;
if ( ! found_interface_decl )
continue ;
if ( found_interface_decl - > getName ( ) = = interface_decl - > getName ( ) )
{
2011-11-17 02:20:47 +08:00
Decl * copied_decl = m_ast_importer - > CopyDecl ( m_ast_context , & method_decl - > getASTContext ( ) , method_decl ) ;
2011-11-12 04:37:26 +08:00
if ( ! copied_decl )
continue ;
ObjCMethodDecl * copied_method_decl = dyn_cast < ObjCMethodDecl > ( copied_decl ) ;
if ( ! copied_method_decl )
continue ;
if ( log )
{
ASTDumper dumper ( ( Decl * ) copied_method_decl ) ;
2011-12-06 11:41:14 +08:00
log - > Printf ( " CAS::FOMD[%d] found (in debug info) %s " , current_id , dumper . GetCString ( ) ) ;
2011-11-12 04:37:26 +08:00
}
2012-01-19 10:17:40 +08:00
2011-11-12 04:37:26 +08:00
context . AddNamedDecl ( copied_method_decl ) ;
}
}
2011-11-10 03:33:21 +08:00
}
2012-02-04 16:49:35 +08:00
template < class D > class TaggedASTDecl {
public :
TaggedASTDecl ( ) : decl ( NULL ) { }
TaggedASTDecl ( D * _decl ) : decl ( _decl ) { }
bool IsValid ( ) const { return ( decl ! = NULL ) ; }
bool IsInvalid ( ) const { return ! IsValid ( ) ; }
D * operator - > ( ) const { return decl ; }
D * decl ;
} ;
template < class D2 , template < class D > class TD , class D1 >
TD < D2 >
DynCast ( TD < D1 > source )
{
return TD < D2 > ( dyn_cast < D2 > ( source . decl ) ) ;
}
template < class D = Decl > class DeclFromParser ;
template < class D = Decl > class DeclFromUser ;
template < class D > class DeclFromParser : public TaggedASTDecl < D > {
public :
DeclFromParser ( ) : TaggedASTDecl < D > ( ) { }
DeclFromParser ( D * _decl ) : TaggedASTDecl < D > ( _decl ) { }
DeclFromUser < D > GetOrigin ( ClangASTImporter * importer ) ;
} ;
template < class D > class DeclFromUser : public TaggedASTDecl < D > {
public :
DeclFromUser ( ) : TaggedASTDecl < D > ( ) { }
DeclFromUser ( D * _decl ) : TaggedASTDecl < D > ( _decl ) { }
DeclFromParser < D > Import ( ClangASTImporter * importer , ASTContext & dest_ctx ) ;
} ;
template < class D >
DeclFromUser < D >
DeclFromParser < D > : : GetOrigin ( ClangASTImporter * importer )
{
DeclFromUser < > origin_decl ;
importer - > ResolveDeclOrigin ( this - > decl , & origin_decl . decl , NULL ) ;
if ( origin_decl . IsInvalid ( ) )
return DeclFromUser < D > ( ) ;
return DeclFromUser < D > ( dyn_cast < D > ( origin_decl . decl ) ) ;
}
template < class D >
DeclFromParser < D >
DeclFromUser < D > : : Import ( ClangASTImporter * importer , ASTContext & dest_ctx )
{
DeclFromParser < > parser_generic_decl ( importer - > CopyDecl ( & dest_ctx , & this - > decl - > getASTContext ( ) , this - > decl ) ) ;
if ( parser_generic_decl . IsInvalid ( ) )
return DeclFromParser < D > ( ) ;
return DeclFromParser < D > ( dyn_cast < D > ( parser_generic_decl . decl ) ) ;
}
2012-02-23 07:57:45 +08:00
static bool
FindObjCPropertyAndIvarDeclsWithOrigin ( unsigned int current_id ,
NameSearchContext & context ,
clang : : ASTContext & ast_context ,
ClangASTImporter * ast_importer ,
DeclFromUser < const ObjCInterfaceDecl > & origin_iface_decl )
2011-11-15 10:11:17 +08:00
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2012-02-04 16:49:35 +08:00
if ( origin_iface_decl . IsInvalid ( ) )
2012-02-23 07:57:45 +08:00
return false ;
2011-11-15 10:11:17 +08:00
2012-02-04 16:49:35 +08:00
std : : string name_str = context . m_decl_name . getAsString ( ) ;
StringRef name ( name_str . c_str ( ) ) ;
IdentifierInfo & name_identifier ( origin_iface_decl - > getASTContext ( ) . Idents . get ( name ) ) ;
2011-11-15 10:11:17 +08:00
2012-02-04 16:49:35 +08:00
DeclFromUser < ObjCPropertyDecl > origin_property_decl ( origin_iface_decl - > FindPropertyDeclaration ( & name_identifier ) ) ;
2011-11-15 10:11:17 +08:00
2012-02-23 07:57:45 +08:00
bool found = false ;
2012-02-04 16:49:35 +08:00
if ( origin_property_decl . IsValid ( ) )
{
2012-02-23 07:57:45 +08:00
DeclFromParser < ObjCPropertyDecl > parser_property_decl ( origin_property_decl . Import ( ast_importer , ast_context ) ) ;
2012-02-04 16:49:35 +08:00
if ( parser_property_decl . IsValid ( ) )
{
if ( log )
{
ASTDumper dumper ( ( Decl * ) parser_property_decl . decl ) ;
log - > Printf ( " CAS::FOPD[%d] found %s " , current_id , dumper . GetCString ( ) ) ;
}
context . AddNamedDecl ( parser_property_decl . decl ) ;
2012-02-23 07:57:45 +08:00
found = true ;
2012-02-04 16:49:35 +08:00
}
}
DeclFromUser < ObjCIvarDecl > origin_ivar_decl ( origin_iface_decl - > getIvarDecl ( & name_identifier ) ) ;
if ( origin_ivar_decl . IsValid ( ) )
{
2012-02-23 07:57:45 +08:00
DeclFromParser < ObjCIvarDecl > parser_ivar_decl ( origin_ivar_decl . Import ( ast_importer , ast_context ) ) ;
2012-02-04 16:49:35 +08:00
if ( parser_ivar_decl . IsValid ( ) )
{
if ( log )
{
ASTDumper dumper ( ( Decl * ) parser_ivar_decl . decl ) ;
log - > Printf ( " CAS::FOPD[%d] found %s " , current_id , dumper . GetCString ( ) ) ;
}
context . AddNamedDecl ( parser_ivar_decl . decl ) ;
2012-02-23 07:57:45 +08:00
found = true ;
2012-02-04 16:49:35 +08:00
}
}
2012-02-23 07:57:45 +08:00
return found ;
}
void
ClangASTSource : : FindObjCPropertyAndIvarDecls ( NameSearchContext & context )
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
DeclFromParser < const ObjCInterfaceDecl > parser_iface_decl ( cast < ObjCInterfaceDecl > ( context . m_decl_context ) ) ;
DeclFromUser < const ObjCInterfaceDecl > origin_iface_decl ( parser_iface_decl . GetOrigin ( m_ast_importer ) ) ;
ConstString class_name ( parser_iface_decl - > getNameAsString ( ) . c_str ( ) ) ;
if ( log )
log - > Printf ( " ClangASTSource::FindObjCPropertyAndIvarDecls[%d] on (ASTContext*)%p for '%s.%s' " ,
current_id ,
m_ast_context ,
parser_iface_decl - > getNameAsString ( ) . c_str ( ) ,
context . m_decl_name . getAsString ( ) . c_str ( ) ) ;
if ( FindObjCPropertyAndIvarDeclsWithOrigin ( current_id ,
context ,
* m_ast_context ,
m_ast_importer ,
origin_iface_decl ) )
return ;
if ( log )
log - > Printf ( " CAS::FOPD[%d] couldn't find the property on origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p, searching elsewhere... " ,
current_id ,
origin_iface_decl . decl ,
& origin_iface_decl - > getASTContext ( ) ) ;
SymbolContext null_sc ;
TypeList type_list ;
lldb : : ProcessSP process ( m_target - > GetProcessSP ( ) ) ;
if ( ! process )
return ;
ObjCLanguageRuntime * language_runtime ( process - > GetObjCLanguageRuntime ( ) ) ;
if ( ! language_runtime )
return ;
lldb : : TypeSP complete_type_sp ( language_runtime - > LookupInCompleteClassCache ( class_name ) ) ;
if ( ! complete_type_sp )
return ;
TypeFromUser complete_type = TypeFromUser ( complete_type_sp - > GetClangFullType ( ) , complete_type_sp - > GetClangAST ( ) ) ;
lldb : : clang_type_t complete_opaque_type = complete_type . GetOpaqueQualType ( ) ;
if ( ! complete_opaque_type )
return ;
const clang : : Type * complete_clang_type = QualType : : getFromOpaquePtr ( complete_opaque_type ) . getTypePtr ( ) ;
const ObjCInterfaceType * complete_interface_type = dyn_cast < ObjCInterfaceType > ( complete_clang_type ) ;
if ( ! complete_interface_type )
return ;
DeclFromUser < const ObjCInterfaceDecl > complete_iface_decl ( complete_interface_type - > getDecl ( ) ) ;
if ( complete_iface_decl . decl = = origin_iface_decl . decl )
return ; // already checked this one
if ( log )
log - > Printf ( " CAS::FOPD[%d] trying origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p... " ,
current_id ,
complete_iface_decl . decl ,
& complete_iface_decl - > getASTContext ( ) ) ;
if ( FindObjCPropertyAndIvarDeclsWithOrigin ( current_id ,
context ,
* m_ast_context ,
m_ast_importer ,
complete_iface_decl ) )
return ;
2012-02-04 16:49:35 +08:00
}
typedef llvm : : DenseMap < const FieldDecl * , uint64_t > FieldOffsetMap ;
typedef llvm : : DenseMap < const CXXRecordDecl * , CharUnits > BaseOffsetMap ;
template < class D , class O >
static bool
ImportOffsetMap ( llvm : : DenseMap < const D * , O > & destination_map ,
llvm : : DenseMap < const D * , O > & source_map ,
ClangASTImporter * importer ,
ASTContext & dest_ctx )
{
typedef llvm : : DenseMap < const D * , O > MapType ;
for ( typename MapType : : iterator fi = source_map . begin ( ) , fe = source_map . end ( ) ;
fi ! = fe ;
+ + fi )
{
DeclFromUser < D > user_decl ( const_cast < D * > ( fi - > first ) ) ;
DeclFromParser < D > parser_decl ( user_decl . Import ( importer , dest_ctx ) ) ;
if ( parser_decl . IsInvalid ( ) )
return false ;
destination_map . insert ( std : : pair < const D * , O > ( parser_decl . decl , fi - > second ) ) ;
}
return true ;
}
template < bool IsVirtual > bool ExtractBaseOffsets ( const ASTRecordLayout & record_layout ,
DeclFromUser < const CXXRecordDecl > & record ,
BaseOffsetMap & base_offsets )
{
for ( CXXRecordDecl : : base_class_const_iterator
bi = ( IsVirtual ? record - > vbases_begin ( ) : record - > bases_begin ( ) ) ,
be = ( IsVirtual ? record - > vbases_end ( ) : record - > bases_end ( ) ) ;
bi ! = be ;
+ + bi )
{
if ( ! IsVirtual & & bi - > isVirtual ( ) )
continue ;
const clang : : Type * origin_base_type = bi - > getType ( ) . getTypePtr ( ) ;
const clang : : RecordType * origin_base_record_type = origin_base_type - > getAs < RecordType > ( ) ;
if ( ! origin_base_record_type )
return false ;
DeclFromUser < RecordDecl > origin_base_record ( origin_base_record_type - > getDecl ( ) ) ;
if ( origin_base_record . IsInvalid ( ) )
return false ;
DeclFromUser < CXXRecordDecl > origin_base_cxx_record ( DynCast < CXXRecordDecl > ( origin_base_record ) ) ;
if ( origin_base_cxx_record . IsInvalid ( ) )
return false ;
CharUnits base_offset ;
if ( IsVirtual )
base_offset = record_layout . getVBaseClassOffset ( origin_base_cxx_record . decl ) ;
else
base_offset = record_layout . getBaseClassOffset ( origin_base_cxx_record . decl ) ;
base_offsets . insert ( std : : pair < const CXXRecordDecl * , CharUnits > ( origin_base_cxx_record . decl , base_offset ) ) ;
}
return true ;
}
bool
ClangASTSource : : layoutRecordType ( const RecordDecl * record ,
uint64_t & size ,
uint64_t & alignment ,
FieldOffsetMap & field_offsets ,
BaseOffsetMap & base_offsets ,
BaseOffsetMap & virtual_base_offsets )
{
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-11-15 10:11:17 +08:00
if ( log )
2012-02-04 16:49:35 +08:00
{
log - > Printf ( " LayoutRecordType[%u] on (RecordDecl*)%p [name = '%s'] " ,
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2012-02-04 16:49:35 +08:00
record - > getNameAsString ( ) . c_str ( ) ) ;
}
2011-11-15 10:11:17 +08:00
2012-02-04 16:49:35 +08:00
DeclFromParser < const RecordDecl > parser_record ( record ) ;
DeclFromUser < const RecordDecl > origin_record ( parser_record . GetOrigin ( m_ast_importer ) ) ;
2011-11-15 10:11:17 +08:00
2012-02-04 16:49:35 +08:00
if ( origin_record . IsInvalid ( ) )
return false ;
FieldOffsetMap origin_field_offsets ;
BaseOffsetMap origin_base_offsets ;
BaseOffsetMap origin_virtual_base_offsets ;
2011-11-15 10:11:17 +08:00
2012-04-07 08:06:00 +08:00
ClangASTContext : : GetCompleteDecl ( & origin_record - > getASTContext ( ) , const_cast < RecordDecl * > ( origin_record . decl ) ) ;
if ( ! origin_record . decl - > getDefinition ( ) )
return false ;
2012-02-04 16:49:35 +08:00
const ASTRecordLayout & record_layout ( origin_record - > getASTContext ( ) . getASTRecordLayout ( origin_record . decl ) ) ;
2011-11-15 10:11:17 +08:00
2012-02-04 16:49:35 +08:00
int field_idx = 0 ;
for ( RecordDecl : : field_iterator fi = origin_record - > field_begin ( ) , fe = origin_record - > field_end ( ) ;
fi ! = fe ;
+ + fi )
{
uint64_t field_offset = record_layout . getFieldOffset ( field_idx ) ;
origin_field_offsets . insert ( std : : pair < const FieldDecl * , uint64_t > ( * fi , field_offset ) ) ;
field_idx + + ;
}
ASTContext & parser_ast_context ( record - > getASTContext ( ) ) ;
DeclFromUser < const CXXRecordDecl > origin_cxx_record ( DynCast < const CXXRecordDecl > ( origin_record ) ) ;
if ( origin_cxx_record . IsValid ( ) )
{
if ( ! ExtractBaseOffsets < false > ( record_layout , origin_cxx_record , origin_base_offsets ) | |
! ExtractBaseOffsets < true > ( record_layout , origin_cxx_record , origin_virtual_base_offsets ) )
return false ;
}
if ( ! ImportOffsetMap ( field_offsets , origin_field_offsets , m_ast_importer , parser_ast_context ) | |
! ImportOffsetMap ( base_offsets , origin_base_offsets , m_ast_importer , parser_ast_context ) | |
! ImportOffsetMap ( virtual_base_offsets , origin_virtual_base_offsets , m_ast_importer , parser_ast_context ) )
return false ;
size = record_layout . getSize ( ) . getQuantity ( ) * m_ast_context - > getCharWidth ( ) ;
alignment = record_layout . getAlignment ( ) . getQuantity ( ) * m_ast_context - > getCharWidth ( ) ;
2011-11-15 10:11:17 +08:00
if ( log )
{
2012-02-04 16:49:35 +08:00
log - > Printf ( " LRT[%u] returned: " , current_id ) ;
log - > Printf ( " LRT[%u] Original = (RecordDecl*)%p " , current_id , origin_record . decl ) ;
log - > Printf ( " LRT[%u] Size = %lld " , current_id , size ) ;
log - > Printf ( " LRT[%u] Alignment = %lld " , current_id , alignment ) ;
log - > Printf ( " LRT[%u] Fields: " , current_id ) ;
for ( RecordDecl : : field_iterator fi = record - > field_begin ( ) , fe = record - > field_end ( ) ;
fi ! = fe ;
+ + fi )
{
log - > Printf ( " LRT[%u] (FieldDecl*)%p, Name = '%s', Offset = %lld bits " ,
current_id ,
* fi ,
fi - > getNameAsString ( ) . c_str ( ) ,
field_offsets [ * fi ] ) ;
}
DeclFromParser < const CXXRecordDecl > parser_cxx_record = DynCast < const CXXRecordDecl > ( parser_record ) ;
if ( parser_cxx_record . IsValid ( ) )
{
log - > Printf ( " LRT[%u] Bases: " , current_id ) ;
for ( CXXRecordDecl : : base_class_const_iterator bi = parser_cxx_record - > bases_begin ( ) , be = parser_cxx_record - > bases_end ( ) ;
bi ! = be ;
+ + bi )
{
bool is_virtual = bi - > isVirtual ( ) ;
QualType base_type = bi - > getType ( ) ;
const RecordType * base_record_type = base_type - > getAs < RecordType > ( ) ;
DeclFromParser < RecordDecl > base_record ( base_record_type - > getDecl ( ) ) ;
DeclFromParser < CXXRecordDecl > base_cxx_record = DynCast < CXXRecordDecl > ( base_record ) ;
log - > Printf ( " LRT[%u] %s(CXXRecordDecl*)%p, Name = '%s', Offset = %lld chars " ,
current_id ,
( is_virtual ? " Virtual " : " " ) ,
base_cxx_record . decl ,
base_cxx_record . decl - > getNameAsString ( ) . c_str ( ) ,
( is_virtual ? virtual_base_offsets [ base_cxx_record . decl ] . getQuantity ( ) :
base_offsets [ base_cxx_record . decl ] . getQuantity ( ) ) ) ;
}
}
else
{
log - > Printf ( " LRD[%u] Not a CXXRecord, so no bases " , current_id ) ;
}
2011-11-15 10:11:17 +08:00
}
2012-02-04 16:49:35 +08:00
return true ;
2011-11-15 10:11:17 +08:00
}
2011-10-29 09:58:46 +08:00
void
ClangASTSource : : CompleteNamespaceMap ( ClangASTImporter : : NamespaceMapSP & namespace_map ,
const ConstString & name ,
ClangASTImporter : : NamespaceMapSP & parent_map ) const
{
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
if ( log )
{
if ( parent_map & & parent_map - > size ( ) )
2011-11-18 11:28:09 +08:00
log - > Printf ( " CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for namespace %s in namespace %s " ,
2011-10-29 09:58:46 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2011-10-29 09:58:46 +08:00
name . GetCString ( ) ,
parent_map - > begin ( ) - > second . GetNamespaceDecl ( ) - > getDeclName ( ) . getAsString ( ) . c_str ( ) ) ;
else
2011-11-18 11:28:09 +08:00
log - > Printf ( " CompleteNamespaceMap[%u] on (ASTContext*)%p Searching for namespace %s " ,
2011-10-29 09:58:46 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2011-10-29 09:58:46 +08:00
name . GetCString ( ) ) ;
}
if ( parent_map )
{
for ( ClangASTImporter : : NamespaceMap : : iterator i = parent_map - > begin ( ) , e = parent_map - > end ( ) ;
i ! = e ;
+ + i )
{
ClangNamespaceDecl found_namespace_decl ;
lldb : : ModuleSP module_sp = i - > first ;
ClangNamespaceDecl module_parent_namespace_decl = i - > second ;
SymbolVendor * symbol_vendor = module_sp - > GetSymbolVendor ( ) ;
if ( ! symbol_vendor )
continue ;
SymbolContext null_sc ;
found_namespace_decl = symbol_vendor - > FindNamespace ( null_sc , name , & module_parent_namespace_decl ) ;
if ( ! found_namespace_decl )
continue ;
namespace_map - > push_back ( std : : pair < lldb : : ModuleSP , ClangNamespaceDecl > ( module_sp , found_namespace_decl ) ) ;
if ( log )
log - > Printf ( " CMN[%u] Found namespace %s in module %s " ,
current_id ,
name . GetCString ( ) ,
module_sp - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
}
}
else
{
ModuleList & images = m_target - > GetImages ( ) ;
ClangNamespaceDecl null_namespace_decl ;
for ( uint32_t i = 0 , e = images . GetSize ( ) ;
i ! = e ;
+ + i )
{
lldb : : ModuleSP image = images . GetModuleAtIndex ( i ) ;
if ( ! image )
continue ;
ClangNamespaceDecl found_namespace_decl ;
SymbolVendor * symbol_vendor = image - > GetSymbolVendor ( ) ;
if ( ! symbol_vendor )
continue ;
SymbolContext null_sc ;
found_namespace_decl = symbol_vendor - > FindNamespace ( null_sc , name , & null_namespace_decl ) ;
if ( ! found_namespace_decl )
continue ;
namespace_map - > push_back ( std : : pair < lldb : : ModuleSP , ClangNamespaceDecl > ( image , found_namespace_decl ) ) ;
if ( log )
log - > Printf ( " CMN[%u] Found namespace %s in module %s " ,
current_id ,
name . GetCString ( ) ,
image - > GetFileSpec ( ) . GetFilename ( ) . GetCString ( ) ) ;
}
}
}
2011-10-29 10:28:18 +08:00
NamespaceDecl *
ClangASTSource : : AddNamespace ( NameSearchContext & context , ClangASTImporter : : NamespaceMapSP & namespace_decls )
{
2012-01-30 04:56:30 +08:00
if ( ! namespace_decls )
2011-10-29 10:28:18 +08:00
return NULL ;
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
const ClangNamespaceDecl & namespace_decl = namespace_decls - > begin ( ) - > second ;
2011-11-17 02:20:47 +08:00
Decl * copied_decl = m_ast_importer - > CopyDecl ( m_ast_context , namespace_decl . GetASTContext ( ) , namespace_decl . GetNamespaceDecl ( ) ) ;
2011-10-29 10:28:18 +08:00
2012-03-21 05:11:12 +08:00
if ( ! copied_decl )
return NULL ;
2011-10-29 10:28:18 +08:00
NamespaceDecl * copied_namespace_decl = dyn_cast < NamespaceDecl > ( copied_decl ) ;
m_ast_importer - > RegisterNamespaceMap ( copied_namespace_decl , namespace_decls ) ;
return dyn_cast < NamespaceDecl > ( copied_decl ) ;
}
2011-10-30 03:50:43 +08:00
void *
ClangASTSource : : GuardedCopyType ( ASTContext * dest_context ,
ASTContext * source_context ,
void * clang_type )
{
SetImportInProgress ( true ) ;
2011-11-17 02:20:47 +08:00
QualType ret_qual_type = m_ast_importer - > CopyType ( m_ast_context , source_context , QualType : : getFromOpaquePtr ( clang_type ) ) ;
2011-10-30 03:50:43 +08:00
void * ret = ret_qual_type . getAsOpaquePtr ( ) ;
SetImportInProgress ( false ) ;
2012-03-21 05:11:12 +08:00
if ( ret & & ret_qual_type - > getCanonicalTypeInternal ( ) . isNull ( ) )
2012-02-28 03:22:39 +08:00
// this shouldn't happen, but we're hardening because the AST importer seems to be generating bad types
// on occasion.
return NULL ;
2011-10-30 03:50:43 +08:00
return ret ;
}
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
clang : : NamedDecl *
NameSearchContext : : AddVarDecl ( void * type )
{
2010-10-16 06:48:33 +08:00
IdentifierInfo * ii = m_decl_name . getAsIdentifierInfo ( ) ;
2010-11-30 08:27:43 +08:00
assert ( type & & " Type for variable must be non-NULL! " ) ;
2010-09-15 05:59:34 +08:00
2011-10-29 07:38:38 +08:00
clang : : NamedDecl * Decl = VarDecl : : Create ( * m_ast_source . m_ast_context ,
2010-10-16 06:48:33 +08:00
const_cast < DeclContext * > ( m_decl_context ) ,
2010-06-09 00:52:24 +08:00
SourceLocation ( ) ,
2011-03-15 08:17:19 +08:00
SourceLocation ( ) ,
2010-09-15 05:59:34 +08:00
ii ,
2010-06-09 00:52:24 +08:00
QualType : : getFromOpaquePtr ( type ) ,
0 ,
2010-09-23 11:01:22 +08:00
SC_Static ,
SC_Static ) ;
2010-10-16 06:48:33 +08:00
m_decls . push_back ( Decl ) ;
2010-06-09 00:52:24 +08:00
return Decl ;
}
2010-06-23 07:46:24 +08:00
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
clang : : NamedDecl *
NameSearchContext : : AddFunDecl ( void * type )
{
2012-03-22 01:13:20 +08:00
assert ( type & & " Type for variable must be non-NULL! " ) ;
2011-10-29 07:38:38 +08:00
clang : : FunctionDecl * func_decl = FunctionDecl : : Create ( * m_ast_source . m_ast_context ,
2010-10-16 06:48:33 +08:00
const_cast < DeclContext * > ( m_decl_context ) ,
SourceLocation ( ) ,
2011-03-15 08:17:19 +08:00
SourceLocation ( ) ,
2010-10-16 06:48:33 +08:00
m_decl_name . getAsIdentifierInfo ( ) ,
QualType : : getFromOpaquePtr ( type ) ,
NULL ,
SC_Static ,
SC_Static ,
false ,
true ) ;
2010-06-23 07:46:24 +08:00
2010-08-13 07:45:38 +08:00
// We have to do more than just synthesize the FunctionDecl. We have to
// synthesize ParmVarDecls for all of the FunctionDecl's arguments. To do
// this, we raid the function's FunctionProtoType for types.
2010-10-16 06:48:33 +08:00
QualType qual_type ( QualType : : getFromOpaquePtr ( type ) ) ;
2011-12-14 09:13:04 +08:00
const FunctionProtoType * func_proto_type = qual_type . getTypePtr ( ) - > getAs < FunctionProtoType > ( ) ;
2010-06-23 07:46:24 +08:00
2010-10-16 06:48:33 +08:00
if ( func_proto_type )
2010-06-24 02:58:10 +08:00
{
2010-10-16 06:48:33 +08:00
unsigned NumArgs = func_proto_type - > getNumArgs ( ) ;
2010-06-23 07:46:24 +08:00
unsigned ArgIndex ;
2011-10-08 07:18:13 +08:00
SmallVector < ParmVarDecl * , 5 > parm_var_decls ;
2010-06-23 07:46:24 +08:00
for ( ArgIndex = 0 ; ArgIndex < NumArgs ; + + ArgIndex )
{
2010-10-16 06:48:33 +08:00
QualType arg_qual_type ( func_proto_type - > getArgType ( ArgIndex ) ) ;
2010-06-23 07:46:24 +08:00
2011-10-29 07:38:38 +08:00
parm_var_decls . push_back ( ParmVarDecl : : Create ( * m_ast_source . m_ast_context ,
2011-10-08 07:18:13 +08:00
const_cast < DeclContext * > ( m_decl_context ) ,
SourceLocation ( ) ,
SourceLocation ( ) ,
NULL ,
arg_qual_type ,
NULL ,
SC_Static ,
SC_Static ,
NULL ) ) ;
2010-06-23 07:46:24 +08:00
}
2011-10-08 07:18:13 +08:00
func_decl - > setParams ( ArrayRef < ParmVarDecl * > ( parm_var_decls ) ) ;
2010-06-23 07:46:24 +08:00
}
2011-12-02 05:04:37 +08:00
else
{
lldb : : LogSP log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
log - > Printf ( " Function type wasn't a FunctionProtoType " ) ;
}
2010-06-23 07:46:24 +08:00
2010-10-16 06:48:33 +08:00
m_decls . push_back ( func_decl ) ;
2010-06-23 07:46:24 +08:00
2010-10-16 06:48:33 +08:00
return func_decl ;
2010-06-23 07:46:24 +08:00
}
2010-07-27 08:55:47 +08:00
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
clang : : NamedDecl *
NameSearchContext : : AddGenericFunDecl ( )
2010-07-27 08:55:47 +08:00
{
2011-01-19 07:32:05 +08:00
FunctionProtoType : : ExtProtoInfo proto_info ;
proto_info . Variadic = true ;
2011-10-29 07:38:38 +08:00
QualType generic_function_type ( m_ast_source . m_ast_context - > getFunctionType ( m_ast_source . m_ast_context - > UnknownAnyTy , // result
NULL , // argument types
0 , // number of arguments
proto_info ) ) ;
2010-10-16 06:48:33 +08:00
2010-07-27 08:55:47 +08:00
return AddFunDecl ( generic_function_type . getAsOpaquePtr ( ) ) ;
}
2010-08-04 09:02:13 +08:00
A few of the issue I have been trying to track down and fix have been due to
the way LLDB lazily gets complete definitions for types within the debug info.
When we run across a class/struct/union definition in the DWARF, we will only
parse the full definition if we need to. This works fine for top level types
that are assigned directly to variables and arguments, but when we have a
variable with a class, lets say "A" for this example, that has a member:
"B *m_b". Initially we don't need to hunt down a definition for this class
unless we are ever asked to do something with it ("expr m_b->getDecl()" for
example). With my previous approach to lazy type completion, we would be able
to take a "A *a" and get a complete type for it, but we wouldn't be able to
then do an "a->m_b->getDecl()" unless we always expanded all types within a
class prior to handing out the type. Expanding everything is very costly and
it would be great if there were a better way.
A few months ago I worked with the llvm/clang folks to have the
ExternalASTSource class be able to complete classes if there weren't completed
yet:
class ExternalASTSource {
....
virtual void
CompleteType (clang::TagDecl *Tag);
virtual void
CompleteType (clang::ObjCInterfaceDecl *Class);
};
This was great, because we can now have the class that is producing the AST
(SymbolFileDWARF and SymbolFileDWARFDebugMap) sign up as external AST sources
and the object that creates the forward declaration types can now also
complete them anywhere within the clang type system.
This patch makes a few major changes:
- lldb_private::Module classes now own the AST context. Previously the TypeList
objects did.
- The DWARF parsers now sign up as an external AST sources so they can complete
types.
- All of the pure clang type system wrapper code we have in LLDB (ClangASTContext,
ClangASTType, and more) can now be iterating through children of any type,
and if a class/union/struct type (clang::RecordType or ObjC interface)
is found that is incomplete, we can ask the AST to get the definition.
- The SymbolFileDWARFDebugMap class now will create and use a single AST that
all child SymbolFileDWARF classes will share (much like what happens when
we have a complete linked DWARF for an executable).
We will need to modify some of the ClangUserExpression code to take more
advantage of this completion ability in the near future. Meanwhile we should
be better off now that we can be accessing any children of variables through
pointers and always be able to resolve the clang type if needed.
llvm-svn: 123613
2011-01-17 11:46:26 +08:00
clang : : NamedDecl *
NameSearchContext : : AddTypeDecl ( void * type )
2010-08-04 09:02:13 +08:00
{
2011-01-23 08:34:52 +08:00
if ( type )
2010-08-04 09:02:13 +08:00
{
2011-01-23 08:34:52 +08:00
QualType qual_type = QualType : : getFromOpaquePtr ( type ) ;
2011-12-14 09:13:04 +08:00
if ( const TagType * tag_type = qual_type - > getAs < TagType > ( ) )
2011-01-23 08:34:52 +08:00
{
TagDecl * tag_decl = tag_type - > getDecl ( ) ;
m_decls . push_back ( tag_decl ) ;
return tag_decl ;
}
2011-12-14 09:13:04 +08:00
else if ( const ObjCObjectType * objc_object_type = qual_type - > getAs < ObjCObjectType > ( ) )
2011-01-23 08:34:52 +08:00
{
ObjCInterfaceDecl * interface_decl = objc_object_type - > getInterface ( ) ;
m_decls . push_back ( ( NamedDecl * ) interface_decl ) ;
return ( NamedDecl * ) interface_decl ;
}
2010-08-04 09:02:13 +08:00
}
2011-01-23 08:34:52 +08:00
return NULL ;
2010-08-04 09:02:13 +08:00
}
2011-06-25 08:44:06 +08:00
void
NameSearchContext : : AddLookupResult ( clang : : DeclContextLookupConstResult result )
{
for ( clang : : NamedDecl * const * decl_iterator = result . first ;
decl_iterator ! = result . second ;
+ + decl_iterator )
m_decls . push_back ( * decl_iterator ) ;
}
void
NameSearchContext : : AddNamedDecl ( clang : : NamedDecl * decl )
{
m_decls . push_back ( decl ) ;
}
