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"
<rdar://problem/11757916>
Make breakpoint setting by file and line much more efficient by only looking for inlined breakpoint locations if we are setting a breakpoint in anything but a source implementation file. Implementing this complex for a many reasons. Turns out that parsing compile units lazily had some issues with respect to how we need to do things with DWARF in .o files. So the fixes in the checkin for this makes these changes:
- Add a new setting called "target.inline-breakpoint-strategy" which can be set to "never", "always", or "headers". "never" will never try and set any inlined breakpoints (fastest). "always" always looks for inlined breakpoint locations (slowest, but most accurate). "headers", which is the default setting, will only look for inlined breakpoint locations if the breakpoint is set in what are consudered to be header files, which is realy defined as "not in an implementation source file".
- modify the breakpoint setting by file and line to check the current "target.inline-breakpoint-strategy" setting and act accordingly
- Modify compile units to be able to get their language and other info lazily. This allows us to create compile units from the debug map and not have to fill all of the details in, and then lazily discover this information as we go on debuggging. This is needed to avoid parsing all .o files when setting breakpoints in implementation only files (no inlines). Otherwise we would need to parse the .o file, the object file (mach-o in our case) and the symbol file (DWARF in the object file) just to see what the compile unit was.
- modify the "SymbolFileDWARFDebugMap" to subclass lldb_private::Module so that the virtual "GetObjectFile()" and "GetSymbolVendor()" functions can be intercepted when the .o file contenst are later lazilly needed. Prior to this fix, when we first instantiated the "SymbolFileDWARFDebugMap" class, we would also make modules, object files and symbol files for every .o file in the debug map because we needed to fix up the sections in the .o files with information that is in the executable debug map. Now we lazily do this in the DebugMapModule::GetObjectFile()
Cleaned up header includes a bit as well.
llvm-svn: 162860
2012-08-30 05:13:06 +08:00
# include "lldb/Symbol/Function.h"
2011-10-29 09:58:46 +08:00
# 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.
2013-02-12 16:01:13 +08:00
bool
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 : : 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 )
2013-02-12 16:01:13 +08:00
{
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
}
2011-10-29 07:38:38 +08:00
if ( GetImportInProgress ( ) )
2013-02-12 16:01:13 +08:00
{
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
}
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
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 :
2012-04-26 01:46:01 +08:00
{
clang : : IdentifierInfo * identifier_info = clang_decl_name . getAsIdentifierInfo ( ) ;
if ( ! identifier_info | |
identifier_info - > getBuiltinID ( ) ! = 0 )
{
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
2012-04-26 01:46:01 +08:00
}
}
2010-10-16 06:48:33 +08:00
break ;
2010-06-09 00:52:24 +08:00
// Operator names. Not important for now.
case DeclarationName : : CXXOperatorName :
case DeclarationName : : CXXLiteralOperatorName :
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
2010-06-09 00:52:24 +08:00
// 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 :
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
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 ) ;
2013-02-12 16:01:13 +08:00
SetExternalVisibleDeclsForName ( decl_ctx , clang_decl_name , method_decls ) ;
return ( method_decls . size ( ) > 0 ) ;
2011-11-10 03:33:21 +08:00
}
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 :
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
2010-06-09 00:52:24 +08:00
}
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
{
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
2010-10-16 06:48:33 +08:00
}
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...
2013-02-12 16:01:13 +08:00
SetNoExternalVisibleDeclsForName ( decl_ctx , clang_decl_name ) ;
return false ;
2010-11-13 12:18:24 +08:00
}
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 ) ;
2013-02-12 16:01:13 +08:00
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 ) ;
2013-02-12 16:01:13 +08:00
return ( name_decls . size ( ) ! = 0 ) ;
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
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-29 10:28:18 +08:00
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 ;
2013-07-12 06:46:58 +08:00
ClangASTType clang_type ( type - > GetClangFullType ( ) ) ;
2011-12-09 07:45:45 +08:00
2013-07-12 06:46:58 +08:00
if ( ! clang_type )
2011-12-09 07:45:45 +08:00
continue ;
2013-07-12 06:46:58 +08:00
const TagType * tag_type = clang_type . GetQualType ( ) - > 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 ;
2012-11-08 10:22:02 +08:00
const ModuleList & module_list = m_target - > GetImages ( ) ;
2011-12-09 07:45:45 +08:00
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 ;
2013-07-12 06:46:58 +08:00
ClangASTType clang_type ( type - > GetClangFullType ( ) ) ;
2011-12-09 07:45:45 +08:00
2013-07-12 06:46:58 +08:00
if ( ! clang_type )
2011-12-09 07:45:45 +08:00
continue ;
2013-07-12 06:46:58 +08:00
const TagType * tag_type = clang_type . GetQualType ( ) - > 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 )
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-29 10:28:18 +08:00
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 ) ;
2013-12-20 12:09:05 +08:00
if ( interface_decl - > getSuperClass ( ) & &
interface_decl - > getSuperClass ( ) ! = interface_decl )
CompleteType ( interface_decl - > getSuperClass ( ) ) ;
2011-10-29 10:28:18 +08:00
if ( log )
{
log - > Printf ( " [COID] After: " ) ;
ASTDumper dumper ( ( Decl * ) interface_decl ) ;
dumper . ToLog ( log , " [COID] " ) ;
}
2010-09-23 11:01:22 +08:00
}
2012-09-21 07:21:16 +08:00
clang : : ObjCInterfaceDecl *
ClangASTSource : : GetCompleteObjCInterface ( clang : : ObjCInterfaceDecl * interface_decl )
{
lldb : : ProcessSP process ( m_target - > GetProcessSP ( ) ) ;
if ( ! process )
return NULL ;
ObjCLanguageRuntime * language_runtime ( process - > GetObjCLanguageRuntime ( ) ) ;
if ( ! language_runtime )
return NULL ;
ConstString class_name ( interface_decl - > getNameAsString ( ) . c_str ( ) ) ;
lldb : : TypeSP complete_type_sp ( language_runtime - > LookupInCompleteClassCache ( class_name ) ) ;
if ( ! complete_type_sp )
return NULL ;
2013-07-12 06:46:58 +08:00
TypeFromUser complete_type = TypeFromUser ( complete_type_sp - > GetClangFullType ( ) ) ;
2012-09-21 07:21:16 +08:00
lldb : : clang_type_t complete_opaque_type = complete_type . GetOpaqueQualType ( ) ;
if ( ! complete_opaque_type )
return NULL ;
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 NULL ;
ObjCInterfaceDecl * complete_iface_decl ( complete_interface_type - > getDecl ( ) ) ;
return complete_iface_decl ;
}
2011-07-30 10:42:06 +08:00
clang : : ExternalLoadResult
2012-09-21 07:21:16 +08:00
ClangASTSource : : FindExternalLexicalDecls ( const DeclContext * decl_context ,
2011-10-29 10:28:18 +08:00
bool ( * predicate ) ( Decl : : Kind ) ,
llvm : : SmallVectorImpl < Decl * > & decls )
2013-03-09 04:04:57 +08:00
{
ClangASTMetrics : : RegisterLexicalQuery ( ) ;
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-29 10:28:18 +08:00
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 )
{
2013-02-28 11:12:58 +08:00
log - > Printf ( " FELD[%u] Original decl (ASTContext*)%p (Decl*)%p: " , current_id , original_ctx , original_decl ) ;
2011-10-29 10:28:18 +08:00
ASTDumper ( original_decl ) . ToLog ( log , " " ) ;
}
2012-09-21 07:21:16 +08:00
if ( ObjCInterfaceDecl * original_iface_decl = dyn_cast < ObjCInterfaceDecl > ( original_decl ) )
{
ObjCInterfaceDecl * complete_iface_decl = GetCompleteObjCInterface ( original_iface_decl ) ;
if ( complete_iface_decl & & ( complete_iface_decl ! = original_iface_decl ) )
{
original_decl = complete_iface_decl ;
original_ctx = & complete_iface_decl - > getASTContext ( ) ;
m_ast_importer - > SetDeclOrigin ( context_decl , original_iface_decl ) ;
}
}
2011-10-29 10:28:18 +08:00
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 ) )
2012-09-25 06:25:51 +08:00
log - > Printf ( " FELD[%d] Adding [to %sDecl %s] lexical %sDecl %s " , current_id , context_named_decl - > getDeclKindName ( ) , context_named_decl - > getNameAsString ( ) . c_str ( ) , decl - > getDeclKindName ( ) , ast_dumper . GetCString ( ) ) ;
2011-10-29 10:28:18 +08:00
else
2012-09-25 06:25:51 +08:00
log - > Printf ( " FELD[%d] Adding lexical %sDecl %s " , current_id , decl - > getDeclKindName ( ) , ast_dumper . GetCString ( ) ) ;
2011-10-29 10:28:18 +08:00
}
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 ( ) ;
2013-03-22 06:15:41 +08:00
m_ast_importer - > RequireCompleteType ( copied_field_type ) ;
2012-03-15 09:53:17 +08:00
}
2011-10-29 10:28:18 +08:00
decls . push_back ( copied_decl ) ;
2013-05-09 09:09:49 +08:00
DeclContext * decl_context_non_const = const_cast < DeclContext * > ( decl_context ) ;
if ( copied_decl - > getDeclContext ( ) ! = decl_context )
{
if ( copied_decl - > getDeclContext ( ) - > containsDecl ( copied_decl ) )
copied_decl - > getDeclContext ( ) - > removeDecl ( copied_decl ) ;
copied_decl - > setDeclContext ( decl_context_non_const ) ;
}
if ( ! decl_context_non_const - > containsDecl ( copied_decl ) )
decl_context_non_const - > addDeclInternal ( copied_decl ) ;
2011-10-29 10:28:18 +08:00
}
}
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 ) ;
2013-03-09 04:04:57 +08:00
ClangASTMetrics : : RegisterVisibleQuery ( ) ;
2011-10-30 03:50:43 +08:00
const ConstString name ( context . m_decl_name . getAsString ( ) . c_str ( ) ) ;
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-30 03:50:43 +08:00
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 ) ;
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-30 03:50:43 +08:00
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
{
2012-11-08 10:22:02 +08:00
const ModuleList & target_images = m_target - > GetImages ( ) ;
2012-05-30 10:19:25 +08:00
Mutex : : Locker modules_locker ( target_images . GetMutex ( ) ) ;
2011-10-30 03:50:43 +08:00
2013-01-26 02:06:21 +08:00
for ( size_t i = 0 , e = target_images . GetSize ( ) ; i < e ; + + i )
2011-10-30 03:50:43 +08:00
{
2012-05-30 10:19:25 +08:00
lldb : : ModuleSP image = target_images . GetModuleAtIndexUnlocked ( i ) ;
2011-10-30 03:50:43 +08:00
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> " ) ) ;
}
2012-09-12 05:44:01 +08:00
2013-07-12 06:46:58 +08:00
ClangASTType full_type = type_sp - > GetClangFullType ( ) ;
2011-12-06 11:41:14 +08:00
2013-07-12 06:46:58 +08:00
ClangASTType copied_clang_type ( GuardedCopyType ( full_type ) ) ;
2011-12-06 11:41:14 +08:00
2013-07-12 06:46:58 +08:00
if ( ! copied_clang_type )
2011-12-02 05:04:37 +08:00
{
if ( log )
2012-12-20 07:05:01 +08:00
log - > Printf ( " CAS::FEVD[%u] - Couldn't export a type " ,
2011-12-06 11:41:14 +08:00
current_id ) ;
2011-12-02 05:04:37 +08:00
break ;
}
2013-07-12 06:46:58 +08:00
context . AddTypeDecl ( copied_clang_type ) ;
2011-10-30 03:50:43 +08:00
}
2012-12-20 07:05:01 +08:00
else
{
do
{
// Couldn't find any types elsewhere. Try the Objective-C runtime if one exists.
lldb : : ProcessSP process ( m_target - > GetProcessSP ( ) ) ;
if ( ! process )
break ;
ObjCLanguageRuntime * language_runtime ( process - > GetObjCLanguageRuntime ( ) ) ;
if ( ! language_runtime )
break ;
TypeVendor * type_vendor = language_runtime - > GetTypeVendor ( ) ;
if ( ! type_vendor )
break ;
bool append = false ;
uint32_t max_matches = 1 ;
std : : vector < ClangASTType > types ;
if ( ! type_vendor - > FindTypes ( name ,
append ,
max_matches ,
types ) )
break ;
if ( log )
{
log - > Printf ( " CAS::FEVD[%u] Matching type found for \" %s \" in the runtime " ,
current_id ,
name . GetCString ( ) ) ;
}
2013-07-12 06:46:58 +08:00
ClangASTType copied_clang_type ( GuardedCopyType ( types [ 0 ] ) ) ;
2012-12-20 07:05:01 +08:00
2013-07-12 06:46:58 +08:00
if ( ! copied_clang_type )
2012-12-20 07:05:01 +08:00
{
if ( log )
log - > Printf ( " CAS::FEVD[%u] - Couldn't export a type from the runtime " ,
current_id ) ;
break ;
}
2013-07-12 06:46:58 +08:00
context . AddTypeDecl ( copied_clang_type ) ;
2012-12-20 07:05:01 +08:00
}
while ( 0 ) ;
}
2011-12-01 06:11:59 +08:00
2011-10-30 03:50:43 +08:00
} while ( 0 ) ;
}
2012-11-03 01:09:58 +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-11-28 11:23:20 +08:00
static bool
2012-09-12 05:44:01 +08:00
FindObjCMethodDeclsWithOrigin ( unsigned int current_id ,
NameSearchContext & context ,
ObjCInterfaceDecl * original_interface_decl ,
clang : : ASTContext * ast_context ,
ClangASTImporter * ast_importer ,
const char * log_info )
{
const DeclarationName & decl_name ( context . m_decl_name ) ;
clang : : ASTContext * original_ctx = & original_interface_decl - > getASTContext ( ) ;
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 ( ) ;
2013-06-20 03:04:53 +08:00
unsigned num_args = sel . getNumArgs ( ) ;
2012-09-12 05:44:01 +08:00
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 ) ;
2012-12-22 05:34:42 +08:00
if ( result . empty ( ) )
2012-11-28 11:23:20 +08:00
return false ;
2012-09-12 05:44:01 +08:00
2012-12-22 05:34:42 +08:00
if ( ! result [ 0 ] )
2012-11-28 11:23:20 +08:00
return false ;
2012-09-12 05:44:01 +08:00
2013-09-05 07:25:26 +08:00
for ( NamedDecl * named_decl : result )
2012-09-12 05:44:01 +08:00
{
2013-09-05 07:25:26 +08:00
ObjCMethodDecl * result_method = dyn_cast < ObjCMethodDecl > ( named_decl ) ;
if ( ! result_method )
return false ;
Decl * copied_decl = ast_importer - > CopyDecl ( ast_context , & result_method - > getASTContext ( ) , result_method ) ;
if ( ! copied_decl )
return false ;
ObjCMethodDecl * copied_method_decl = dyn_cast < ObjCMethodDecl > ( copied_decl ) ;
if ( ! copied_method_decl )
return false ;
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
if ( log )
{
ASTDumper dumper ( ( Decl * ) copied_method_decl ) ;
log - > Printf ( " CAS::FOMD[%d] found (%s) %s " , current_id , log_info , dumper . GetCString ( ) ) ;
}
context . AddNamedDecl ( copied_method_decl ) ;
2012-09-12 05:44:01 +08:00
}
2012-11-28 11:23:20 +08:00
return true ;
2012-09-12 05:44:01 +08:00
}
2011-11-10 03:33:21 +08:00
void
ClangASTSource : : FindObjCMethodDecls ( NameSearchContext & context )
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-11-10 03:33:21 +08:00
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 ) ;
2012-11-28 11:23:20 +08:00
if ( FindObjCMethodDeclsWithOrigin ( current_id ,
context ,
original_interface_decl ,
m_ast_context ,
m_ast_importer ,
" at origin " ) )
return ; // found it, no need to look any further
2012-04-05 08:12:52 +08:00
} 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 ( ) ;
2014-02-07 06:24:11 +08:00
if ( strstr ( ss . GetData ( ) , " $__lldb " ) )
return ; // we don't need any results
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
2012-09-12 05:44:01 +08:00
if ( sc_list . GetSize ( ) )
2011-11-12 04:37:26 +08:00
{
2012-09-12 05:44:01 +08:00
// We found a good function symbol. Use that.
2011-11-12 04:37:26 +08:00
2012-09-12 05:44:01 +08:00
for ( uint32_t i = 0 , e = sc_list . GetSize ( ) ;
i ! = e ;
+ + i )
2011-11-12 04:37:26 +08:00
{
2012-09-12 05:44:01 +08:00
SymbolContext sc ;
2011-11-12 04:37:26 +08:00
2012-09-12 05:44:01 +08:00
if ( ! sc_list . GetContextAtIndex ( i , sc ) )
continue ;
if ( ! sc . function )
2011-11-12 04:37:26 +08:00
continue ;
2012-09-12 05:44:01 +08:00
DeclContext * function_ctx = sc . function - > GetClangDeclContext ( ) ;
2011-11-12 04:37:26 +08:00
2012-09-12 05:44:01 +08:00
if ( ! function_ctx )
2011-11-12 04:37:26 +08:00
continue ;
2012-09-12 05:44:01 +08:00
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-12 04:37:26 +08:00
{
2012-09-12 05:44:01 +08:00
Decl * copied_decl = m_ast_importer - > CopyDecl ( m_ast_context , & method_decl - > getASTContext ( ) , method_decl ) ;
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 ) ;
2012-11-03 01:09:58 +08:00
log - > Printf ( " CAS::FOMD[%d] found (in symbols) %s " , current_id , dumper . GetCString ( ) ) ;
2012-09-12 05:44:01 +08:00
}
context . AddNamedDecl ( copied_method_decl ) ;
2011-11-12 04:37:26 +08:00
}
2012-09-12 05:44:01 +08:00
}
2012-11-03 01:09:58 +08:00
return ;
2012-09-12 05:44:01 +08:00
}
2012-11-03 01:09:58 +08:00
// Try the debug information.
do
2012-09-12 05:44:01 +08:00
{
2012-11-03 01:09:58 +08:00
ObjCInterfaceDecl * complete_interface_decl = GetCompleteObjCInterface ( const_cast < ObjCInterfaceDecl * > ( interface_decl ) ) ;
if ( ! complete_interface_decl )
break ;
// We found the complete interface. The runtime never needs to be queried in this scenario.
DeclFromUser < const ObjCInterfaceDecl > complete_iface_decl ( complete_interface_decl ) ;
if ( complete_interface_decl = = interface_decl )
break ; // already checked this one
if ( log )
log - > Printf ( " CAS::FOPD[%d] trying origin (ObjCInterfaceDecl*)%p/(ASTContext*)%p... " ,
current_id ,
complete_interface_decl ,
& complete_iface_decl - > getASTContext ( ) ) ;
FindObjCMethodDeclsWithOrigin ( current_id ,
context ,
complete_interface_decl ,
m_ast_context ,
m_ast_importer ,
" in debug info " ) ;
return ;
2011-11-12 04:37:26 +08:00
}
2012-11-03 01:09:58 +08:00
while ( 0 ) ;
2012-02-04 16:49:35 +08:00
2012-11-03 01:09:58 +08:00
do
{
// Check the runtime only if the debug information didn't have a complete interface.
lldb : : ProcessSP process ( m_target - > GetProcessSP ( ) ) ;
if ( ! process )
break ;
ObjCLanguageRuntime * language_runtime ( process - > GetObjCLanguageRuntime ( ) ) ;
2012-12-20 07:05:01 +08:00
if ( ! language_runtime )
break ;
2012-11-03 01:09:58 +08:00
TypeVendor * type_vendor = language_runtime - > GetTypeVendor ( ) ;
if ( ! type_vendor )
break ;
ConstString interface_name ( interface_decl - > getNameAsString ( ) . c_str ( ) ) ;
bool append = false ;
uint32_t max_matches = 1 ;
std : : vector < ClangASTType > types ;
if ( ! type_vendor - > FindTypes ( interface_name ,
append ,
max_matches ,
types ) )
break ;
const clang : : Type * runtime_clang_type = QualType : : getFromOpaquePtr ( types [ 0 ] . GetOpaqueQualType ( ) ) . getTypePtr ( ) ;
const ObjCInterfaceType * runtime_interface_type = dyn_cast < ObjCInterfaceType > ( runtime_clang_type ) ;
if ( ! runtime_interface_type )
break ;
ObjCInterfaceDecl * runtime_interface_decl = runtime_interface_type - > getDecl ( ) ;
FindObjCMethodDeclsWithOrigin ( current_id ,
context ,
runtime_interface_decl ,
m_ast_context ,
m_ast_importer ,
" in runtime " ) ;
}
while ( 0 ) ;
2012-02-04 16:49:35 +08:00
}
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
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-11-15 10:11:17 +08:00
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 )
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2012-02-23 07:57:45 +08:00
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 ;
2012-09-12 05:44:01 +08:00
do
{
2012-09-21 07:21:16 +08:00
ObjCInterfaceDecl * complete_interface_decl = GetCompleteObjCInterface ( const_cast < ObjCInterfaceDecl * > ( parser_iface_decl . decl ) ) ;
2012-09-12 05:44:01 +08:00
2012-09-21 07:21:16 +08:00
if ( ! complete_interface_decl )
2012-09-12 05:44:01 +08:00
break ;
2012-11-03 01:09:58 +08:00
// We found the complete interface. The runtime never needs to be queried in this scenario.
2012-09-21 07:21:16 +08:00
DeclFromUser < const ObjCInterfaceDecl > complete_iface_decl ( complete_interface_decl ) ;
2012-09-12 05:44:01 +08:00
if ( complete_iface_decl . decl = = origin_iface_decl . decl )
break ; // 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 ( ) ) ;
2012-11-03 01:09:58 +08:00
FindObjCPropertyAndIvarDeclsWithOrigin ( current_id ,
context ,
* m_ast_context ,
m_ast_importer ,
complete_iface_decl ) ;
return ;
2012-09-12 05:44:01 +08:00
}
while ( 0 ) ;
2012-02-23 07:57:45 +08:00
2012-09-12 05:44:01 +08:00
do
{
2012-11-03 01:09:58 +08:00
// Check the runtime only if the debug information didn't have a complete interface.
lldb : : ProcessSP process ( m_target - > GetProcessSP ( ) ) ;
if ( ! process )
return ;
ObjCLanguageRuntime * language_runtime ( process - > GetObjCLanguageRuntime ( ) ) ;
if ( ! language_runtime )
return ;
2012-09-12 05:44:01 +08:00
TypeVendor * type_vendor = language_runtime - > GetTypeVendor ( ) ;
if ( ! type_vendor )
break ;
bool append = false ;
uint32_t max_matches = 1 ;
std : : vector < ClangASTType > types ;
if ( ! type_vendor - > FindTypes ( class_name ,
append ,
max_matches ,
types ) )
break ;
const clang : : Type * runtime_clang_type = QualType : : getFromOpaquePtr ( types [ 0 ] . GetOpaqueQualType ( ) ) . getTypePtr ( ) ;
const ObjCInterfaceType * runtime_interface_type = dyn_cast < ObjCInterfaceType > ( runtime_clang_type ) ;
if ( ! runtime_interface_type )
break ;
DeclFromUser < const ObjCInterfaceDecl > runtime_iface_decl ( runtime_interface_type - > getDecl ( ) ) ;
if ( log )
log - > Printf ( " CAS::FOPD[%d] trying runtime (ObjCInterfaceDecl*)%p/(ASTContext*)%p... " ,
current_id ,
runtime_iface_decl . decl ,
& runtime_iface_decl - > getASTContext ( ) ) ;
if ( FindObjCPropertyAndIvarDeclsWithOrigin ( current_id ,
context ,
* m_ast_context ,
m_ast_importer ,
runtime_iface_decl ) )
return ;
}
while ( 0 ) ;
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 )
{
2013-03-09 04:04:57 +08:00
ClangASTMetrics : : RegisterRecordLayout ( ) ;
2012-02-04 16:49:35 +08:00
static unsigned int invocation_id = 0 ;
unsigned int current_id = invocation_id + + ;
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2012-02-04 16:49:35 +08:00
2011-11-15 10:11:17 +08:00
if ( log )
2012-02-04 16:49:35 +08:00
{
2013-02-28 11:12:58 +08:00
log - > Printf ( " LayoutRecordType[%u] on (ASTContext*)%p for (RecordDecl*)%p [name = '%s'] " ,
2012-02-04 16:49:35 +08:00
current_id ,
2011-11-18 11:28:09 +08:00
m_ast_context ,
2013-02-28 11:12:58 +08:00
record ,
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
2013-03-26 02:27:07 +08:00
int field_idx = 0 , field_count = record_layout . getFieldCount ( ) ;
2012-02-04 16:49:35 +08:00
for ( RecordDecl : : field_iterator fi = origin_record - > field_begin ( ) , fe = origin_record - > field_end ( ) ;
fi ! = fe ;
+ + fi )
{
2013-03-26 02:27:07 +08:00
if ( field_idx > = field_count )
return false ; // Layout didn't go well. Bail out.
2012-02-04 16:49:35 +08:00
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 ) ;
2012-11-30 05:49:15 +08:00
log - > Printf ( " LRT[%u] Size = % " PRId64 , current_id , size ) ;
log - > Printf ( " LRT[%u] Alignment = % " PRId64 , current_id , alignment ) ;
2012-02-04 16:49:35 +08:00
log - > Printf ( " LRT[%u] Fields: " , current_id ) ;
for ( RecordDecl : : field_iterator fi = record - > field_begin ( ) , fe = record - > field_end ( ) ;
fi ! = fe ;
+ + fi )
{
2012-11-30 05:49:15 +08:00
log - > Printf ( " LRT[%u] (FieldDecl*)%p, Name = '%s', Offset = % " PRId64 " bits " ,
2012-02-04 16:49:35 +08:00
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 ) ;
2012-11-30 05:49:15 +08:00
log - > Printf ( " LRT[%u] %s(CXXRecordDecl*)%p, Name = '%s', Offset = % " PRId64 " chars " ,
2012-02-04 16:49:35 +08:00
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 + + ;
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-10-29 09:58:46 +08:00
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
{
2012-11-08 10:22:02 +08:00
const ModuleList & target_images = m_target - > GetImages ( ) ;
2012-05-30 10:19:25 +08:00
Mutex : : Locker modules_locker ( target_images . GetMutex ( ) ) ;
2011-10-29 09:58:46 +08:00
ClangNamespaceDecl null_namespace_decl ;
2013-01-26 02:06:21 +08:00
for ( size_t i = 0 , e = target_images . GetSize ( ) ; i < e ; + + i )
2011-10-29 09:58:46 +08:00
{
2012-05-30 10:19:25 +08:00
lldb : : ModuleSP image = target_images . GetModuleAtIndexUnlocked ( i ) ;
2011-10-29 09:58:46 +08:00
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 ;
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 ;
2013-02-12 16:01:13 +08:00
2011-10-29 10:28:18 +08:00
NamespaceDecl * copied_namespace_decl = dyn_cast < NamespaceDecl > ( copied_decl ) ;
2013-02-12 16:01:13 +08:00
if ( ! copied_namespace_decl )
return NULL ;
context . m_decls . push_back ( copied_namespace_decl ) ;
2011-10-29 10:28:18 +08:00
m_ast_importer - > RegisterNamespaceMap ( copied_namespace_decl , namespace_decls ) ;
return dyn_cast < NamespaceDecl > ( copied_decl ) ;
}
2013-07-12 06:46:58 +08:00
ClangASTType
ClangASTSource : : GuardedCopyType ( const ClangASTType & src_type )
2013-03-09 04:04:57 +08:00
{
ClangASTMetrics : : RegisterLLDBImport ( ) ;
2011-10-30 03:50:43 +08:00
SetImportInProgress ( true ) ;
2013-07-12 06:46:58 +08:00
QualType copied_qual_type = m_ast_importer - > CopyType ( m_ast_context , src_type . GetASTContext ( ) , src_type . GetQualType ( ) ) ;
2011-10-30 03:50:43 +08:00
SetImportInProgress ( false ) ;
2013-07-12 06:46:58 +08:00
if ( copied_qual_type . getAsOpaquePtr ( ) & & copied_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.
2013-07-12 06:46:58 +08:00
return ClangASTType ( ) ;
2012-02-28 03:22:39 +08:00
2013-07-12 06:46:58 +08:00
return ClangASTType ( m_ast_context , copied_qual_type ) ;
2011-10-30 03:50:43 +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 *
2013-07-12 06:46:58 +08:00
NameSearchContext : : AddVarDecl ( const ClangASTType & type )
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
{
2013-07-12 06:46:58 +08:00
assert ( type & & " Type for variable must be valid! " ) ;
if ( ! type . IsValid ( ) )
return NULL ;
2010-10-16 06:48:33 +08:00
IdentifierInfo * ii = m_decl_name . getAsIdentifierInfo ( ) ;
2010-11-30 08:27:43 +08:00
2013-07-12 06:46:58 +08:00
clang : : ASTContext * ast = type . GetASTContext ( ) ;
clang : : NamedDecl * Decl = VarDecl : : Create ( * ast ,
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 ,
2013-07-12 06:46:58 +08:00
type . GetQualType ( ) ,
2010-06-09 00:52:24 +08:00
0 ,
2010-09-23 11:01:22 +08:00
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 *
2013-07-12 06:46:58 +08:00
NameSearchContext : : AddFunDecl ( const ClangASTType & type )
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
{
2013-07-12 06:46:58 +08:00
assert ( type & & " Type for variable must be valid! " ) ;
2012-03-22 01:13:20 +08:00
2013-07-12 06:46:58 +08:00
if ( ! type . IsValid ( ) )
return NULL ;
2013-04-24 08:34:41 +08:00
if ( m_function_types . count ( type ) )
return NULL ;
m_function_types . insert ( type ) ;
2013-07-12 06:46:58 +08:00
QualType qual_type ( type . GetQualType ( ) ) ;
clang : : ASTContext * ast = type . GetASTContext ( ) ;
2013-06-29 05:08:47 +08:00
const bool isInlineSpecified = false ;
const bool hasWrittenPrototype = true ;
const bool isConstexprSpecified = false ;
2013-07-12 06:46:58 +08:00
clang : : FunctionDecl * func_decl = FunctionDecl : : Create ( * ast ,
2010-10-16 06:48:33 +08:00
const_cast < DeclContext * > ( m_decl_context ) ,
SourceLocation ( ) ,
2013-06-29 06:21:22 +08:00
SourceLocation ( ) ,
2010-10-16 06:48:33 +08:00
m_decl_name . getAsIdentifierInfo ( ) ,
2013-07-12 06:46:58 +08:00
qual_type ,
2010-10-16 06:48:33 +08:00
NULL ,
SC_Static ,
2013-06-29 05:08:47 +08:00
isInlineSpecified ,
hasWrittenPrototype ,
isConstexprSpecified ) ;
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.
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
{
2014-01-21 05:14:57 +08:00
unsigned NumArgs = func_proto_type - > getNumParams ( ) ;
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 )
{
2014-01-21 05:14:57 +08:00
QualType arg_qual_type ( func_proto_type - > getParamType ( ArgIndex ) ) ;
2010-06-23 07:46:24 +08:00
2013-07-12 06:46:58 +08:00
parm_var_decls . push_back ( ParmVarDecl : : Create ( * ast ,
2011-10-08 07:18:13 +08:00
const_cast < DeclContext * > ( m_decl_context ) ,
SourceLocation ( ) ,
SourceLocation ( ) ,
NULL ,
arg_qual_type ,
NULL ,
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
{
2013-03-28 07:08:40 +08:00
Log * log ( lldb_private : : GetLogIfAllCategoriesSet ( LIBLLDB_LOG_EXPRESSIONS ) ) ;
2011-12-02 05:04:37 +08:00
2013-04-26 02:50:43 +08:00
if ( log )
log - > Printf ( " Function type wasn't a FunctionProtoType " ) ;
2011-12-02 05:04:37 +08:00
}
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
2013-03-11 04:13:16 +08:00
ArrayRef < QualType > ( ) , // argument types
2011-10-29 07:38:38 +08:00
proto_info ) ) ;
2010-10-16 06:48:33 +08:00
2013-07-12 06:46:58 +08:00
return AddFunDecl ( ClangASTType ( m_ast_source . m_ast_context , generic_function_type ) ) ;
2010-07-27 08:55:47 +08:00
}
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 *
2013-07-12 06:46:58 +08:00
NameSearchContext : : AddTypeDecl ( const ClangASTType & clang_type )
2010-08-04 09:02:13 +08:00
{
2013-07-12 06:46:58 +08:00
if ( clang_type )
2010-08-04 09:02:13 +08:00
{
2013-07-12 06:46:58 +08:00
QualType qual_type = clang_type . GetQualType ( ) ;
2011-01-23 08:34:52 +08:00
2013-06-26 06:36:17 +08:00
if ( const TypedefType * typedef_type = llvm : : dyn_cast < TypedefType > ( qual_type ) )
{
TypedefNameDecl * typedef_name_decl = typedef_type - > getDecl ( ) ;
m_decls . push_back ( typedef_name_decl ) ;
return ( NamedDecl * ) typedef_name_decl ;
}
else 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 )
{
2012-12-22 05:34:42 +08:00
for ( clang : : NamedDecl * decl : result )
m_decls . push_back ( decl ) ;
2011-06-25 08:44:06 +08:00
}
void
NameSearchContext : : AddNamedDecl ( clang : : NamedDecl * decl )
{
m_decls . push_back ( decl ) ;
}
