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

997 lines
32 KiB
C++
Raw Normal View History

This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
//===-- ClangASTImporter.cpp ------------------------------------*- C++ -*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "clang/AST/Decl.h"
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
#include "clang/AST/DeclCXX.h"
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
#include "clang/AST/DeclObjC.h"
Fix clang build issues. llvm-svn: 169140
2012-12-04 02:29:55 +08:00
#include "llvm/Support/raw_ostream.h"
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
#include "lldb/Core/Log.h"
Fixed a missing quote. llvm-svn: 142698
2011-10-22 07:04:20 +08:00
#include "lldb/Core/Module.h"
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangASTImporter.h"
Added a mechanism for keeping track of where in the debug information individual Decls came from. We've had a metadata infrastructure for a while, which was intended to solve a problem we've since dealt with in a different way. (It was meant to keep track of which definition of an Objective-C class was the "true" definition, but we now find it by searching the symbols for the class symbol.) The metadata is attached to the ExternalASTSource, which means it has a one-to-one correspondence with AST contexts. I've repurposed the metadata infrastructure to hold the object file and DIE offset for the DWARF information corresponding to a Decl. There are methods in ClangASTContext that get and set this metadata, and the ClangASTImporter is capable of tracking down the metadata for Decls that have been copied out of the debug information into the parser's AST context without using any additional memory. To see the metadata, you just have to enable the expression log: - (lldb) log enable lldb expr - and watch the import messages. The high 32 bits of the metadata indicate the index of the object file in its containing DWARFDebugMap; I have also added a log which you can use to track that mapping: - (lldb) log enable dwarf map - This adds 64 bits per Decl, which in my testing hasn't turned out to be very much (debugging Clang produces around 6500 Decls in my tests). To track how much data is being consumed, I've also added a global variable g_TotalSizeOfMetadata which tracks the total number of Decls that have metadata in all active AST contexts. Right now this metadata is enormously useful for tracking down bugs in the debug info parser. In the future I also want to use this information to provide more intelligent error messages instead of printing empty source lines wherever Clang refers to the location where something is defined. llvm-svn: 154634
2012-04-13 08:10:03 +08:00
#include "lldb/Symbol/ClangExternalASTSourceCommon.h"
Fixed a serious bug in DeportType where the types could retain DeclContexts that pointed into the artificial function constructed for the expression. I now make anything that pointed to the function as its DeclContext be global while the copy occurs; afterward I restored the old DeclContext. Added a testcase that make sure that this works properly and doesn't crash anything. <rdar://problem/21049838> llvm-svn: 241695
2015-07-09 02:03:41 +08:00
#include "lldb/Utility/LLDBAssert.h"
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
using namespace lldb_private;
using namespace clang;
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
ClangASTMetrics::Counters ClangASTMetrics::global_counters = { 0, 0, 0, 0, 0, 0 };
ClangASTMetrics::Counters ClangASTMetrics::local_counters = { 0, 0, 0, 0, 0, 0 };
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
void ClangASTMetrics::DumpCounters (Log *log, ClangASTMetrics::Counters &counters)
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
{
Misc. clang build warning fixes. llvm-svn: 176879
2013-03-13 01:45:38 +08:00
log->Printf(" Number of visible Decl queries by name : %" PRIu64, counters.m_visible_query_count);
log->Printf(" Number of lexical Decl queries : %" PRIu64, counters.m_lexical_query_count);
log->Printf(" Number of imports initiated by LLDB : %" PRIu64, counters.m_lldb_import_count);
log->Printf(" Number of imports conducted by Clang : %" PRIu64, counters.m_clang_import_count);
log->Printf(" Number of Decls completed : %" PRIu64, counters.m_decls_completed_count);
log->Printf(" Number of records laid out : %" PRIu64, counters.m_record_layout_count);
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
}
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
void ClangASTMetrics::DumpCounters (Log *log)
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
{
if (!log)
return;
log->Printf("== ClangASTMetrics output ==");
log->Printf("-- Global metrics --");
DumpCounters (log, global_counters);
log->Printf("-- Local metrics --");
DumpCounters (log, local_counters);
}
clang::QualType
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
clang::ASTContext *src_ast,
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
clang::QualType type)
{
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
MinionSP minion_sp (GetMinion(dst_ast, src_ast));
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
Fixed an issue that was causing us to crash when evaluating expressions for objective C or C++ methods when "self" or "this" were in scope, but had invalid locations in a DWARF location list. The lack of a valid value caused us to use an invalid type value and then we tried to import that invalid value and we would crash. llvm-svn: 134518
2011-07-07 02:55:08 +08:00
if (minion_sp)
return minion_sp->Import(type);
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
Fixed an issue that was causing us to crash when evaluating expressions for objective C or C++ methods when "self" or "this" were in scope, but had invalid locations in a DWARF location list. The lack of a valid value caused us to use an invalid type value and then we tried to import that invalid value and we would crash. llvm-svn: 134518
2011-07-07 02:55:08 +08:00
return QualType();
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
}
Rename clang_type_t to opaque_compiler_type_t. Summary: This is no longer related to Clang and is just an opaque pointer to data for a compiler type. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D13039 llvm-svn: 248288
2015-09-23 01:04:24 +08:00
lldb::opaque_compiler_type_t
Added a CopyType method to the ASTImporter that handles opaque QualTypes. llvm-svn: 144813
2011-11-17 03:07:39 +08:00
ClangASTImporter::CopyType (clang::ASTContext *dst_ast,
clang::ASTContext *src_ast,
Rename clang_type_t to opaque_compiler_type_t. Summary: This is no longer related to Clang and is just an opaque pointer to data for a compiler type. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D13039 llvm-svn: 248288
2015-09-23 01:04:24 +08:00
lldb::opaque_compiler_type_t type)
Added a CopyType method to the ASTImporter that handles opaque QualTypes. llvm-svn: 144813
2011-11-17 03:07:39 +08:00
{
return CopyType (dst_ast, src_ast, QualType::getFromOpaquePtr(type)).getAsOpaquePtr();
}
Trying to submit 254476 one more time. This implement -gmodule debugging support. It was previously reverted due to issues that showed up only on linux. I was able to reproduce these issues and fix the underlying cause. So this is the same patch as 254476 with the following two fixes: - Fix not trying to complete classes that don't have external sources - Fix ClangASTSource::CompleteType() to check the decl context of types that it finds by basename to ensure we don't complete a type "S" with a type like "std::S". Before this fix ClangASTSource::CompleteType() would accept _any_ type that had a matching basename and copy it into the other type. <rdar://problem/22992457> llvm-svn: 254980
2015-12-08 09:02:08 +08:00
CompilerType
ClangASTImporter::CopyType (ClangASTContext &dst_ast,
const CompilerType &src_type)
{
clang::ASTContext *dst_clang_ast = dst_ast.getASTContext();
if (dst_clang_ast)
{
ClangASTContext *src_ast = llvm::dyn_cast_or_null<ClangASTContext>(src_type.GetTypeSystem());
if (src_ast)
{
clang::ASTContext *src_clang_ast = src_ast->getASTContext();
if (src_clang_ast)
{
lldb::opaque_compiler_type_t dst_clang_type = CopyType(dst_clang_ast,
src_clang_ast,
src_type.GetOpaqueQualType());
if (dst_clang_type)
return CompilerType(&dst_ast, dst_clang_type);
}
}
}
return CompilerType();
}
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
clang::Decl *
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
ClangASTImporter::CopyDecl (clang::ASTContext *dst_ast,
clang::ASTContext *src_ast,
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
clang::Decl *decl)
{
Fixed an issue that was causing us to crash when evaluating expressions for objective C or C++ methods when "self" or "this" were in scope, but had invalid locations in a DWARF location list. The lack of a valid value caused us to use an invalid type value and then we tried to import that invalid value and we would crash. llvm-svn: 134518
2011-07-07 02:55:08 +08:00
MinionSP minion_sp;
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
minion_sp = GetMinion(dst_ast, src_ast);
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
Fixed an issue that was causing us to crash when evaluating expressions for objective C or C++ methods when "self" or "this" were in scope, but had invalid locations in a DWARF location list. The lack of a valid value caused us to use an invalid type value and then we tried to import that invalid value and we would crash. llvm-svn: 134518
2011-07-07 02:55:08 +08:00
if (minion_sp)
Updated LLVM/Clang to pick up a fix for imports of C++ vtables, fixing a record layout problem in the expression parser. Also fixed various problems with the generation and unpacking of llvm.zip given our new better handling of multiple architectures in the LLVM build. (And added a log message that will hopefully catch record layout problems in the future.) llvm-svn: 143741
2011-11-05 06:46:46 +08:00
{
clang::Decl *result = minion_sp->Import(decl);
if (!result)
{
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
Updated LLVM/Clang to pick up a fix for imports of C++ vtables, fixing a record layout problem in the expression parser. Also fixed various problems with the generation and unpacking of llvm.zip given our new better handling of multiple architectures in the LLVM build. (And added a log message that will hopefully catch record layout problems in the future.) llvm-svn: 143741
2011-11-05 06:46:46 +08:00
Wrapped some logging statements in conditionals, to prevent crashes. llvm-svn: 143756
2011-11-05 08:08:12 +08:00
if (log)
{
Give user_id a default invalid value so we don't possibly use it uninitialized in a log message later. clang static analyzer fixit. llvm-svn: 219865
2014-10-16 07:27:12 +08:00
lldb::user_id_t user_id = LLDB_INVALID_UID;
This is the first phase of supporting the DW_AT_object_pointer tag. I expanded the decl metadata so it could hold this information, and then used it to look up unfound names in the object pointer if it exists. This gets "frame var" to work for unqualified references to ivars captured in blocks. But the expression parser is ignoring this information still. llvm-svn: 166860
2012-10-27 10:54:13 +08:00
ClangASTMetadata *metadata = GetDeclMetadata(decl);
if (metadata)
user_id = metadata->GetUserID();
Wrapped some logging statements in conditionals, to prevent crashes. llvm-svn: 143756
2011-11-05 08:08:12 +08:00
if (NamedDecl *named_decl = dyn_cast<NamedDecl>(decl))
Resolve printf formatting warnings on Linux: - use macros from inttypes.h for format strings instead of OS-specific types Patch from Matt Kopec! llvm-svn: 168945
2012-11-30 05:49:15 +08:00
log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s '%s', metadata 0x%" PRIx64,
When an AST import fails, provide the metadata for the original Decl, for debugging purposes. llvm-svn: 154957
2012-04-18 06:30:04 +08:00
decl->getDeclKindName(),
named_decl->getNameAsString().c_str(),
This is the first phase of supporting the DW_AT_object_pointer tag. I expanded the decl metadata so it could hold this information, and then used it to look up unfound names in the object pointer if it exists. This gets "frame var" to work for unqualified references to ivars captured in blocks. But the expression parser is ignoring this information still. llvm-svn: 166860
2012-10-27 10:54:13 +08:00
user_id);
Wrapped some logging statements in conditionals, to prevent crashes. llvm-svn: 143756
2011-11-05 08:08:12 +08:00
else
Resolve printf formatting warnings on Linux: - use macros from inttypes.h for format strings instead of OS-specific types Patch from Matt Kopec! llvm-svn: 168945
2012-11-30 05:49:15 +08:00
log->Printf(" [ClangASTImporter] WARNING: Failed to import a %s, metadata 0x%" PRIx64,
When an AST import fails, provide the metadata for the original Decl, for debugging purposes. llvm-svn: 154957
2012-04-18 06:30:04 +08:00
decl->getDeclKindName(),
This is the first phase of supporting the DW_AT_object_pointer tag. I expanded the decl metadata so it could hold this information, and then used it to look up unfound names in the object pointer if it exists. This gets "frame var" to work for unqualified references to ivars captured in blocks. But the expression parser is ignoring this information still. llvm-svn: 166860
2012-10-27 10:54:13 +08:00
user_id);
Wrapped some logging statements in conditionals, to prevent crashes. llvm-svn: 143756
2011-11-05 08:08:12 +08:00
}
Updated LLVM/Clang to pick up a fix for imports of C++ vtables, fixing a record layout problem in the expression parser. Also fixed various problems with the generation and unpacking of llvm.zip given our new better handling of multiple architectures in the LLVM build. (And added a log message that will hopefully catch record layout problems in the future.) llvm-svn: 143741
2011-11-05 06:46:46 +08:00
}
return result;
}
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
}
Fixed a serious bug in DeportType where the types could retain DeclContexts that pointed into the artificial function constructed for the expression. I now make anything that pointed to the function as its DeclContext be global while the copy occurs; afterward I restored the old DeclContext. Added a testcase that make sure that this works properly and doesn't crash anything. <rdar://problem/21049838> llvm-svn: 241695
2015-07-09 02:03:41 +08:00
class DeclContextOverride
{
private:
struct Backup
{
clang::DeclContext *decl_context;
clang::DeclContext *lexical_decl_context;
};
std::map<clang::Decl *, Backup> m_backups;
void OverrideOne(clang::Decl *decl)
{
if (m_backups.find(decl) != m_backups.end())
{
return;
}
m_backups[decl] = { decl->getDeclContext(), decl->getLexicalDeclContext() };
decl->setDeclContext(decl->getASTContext().getTranslationUnitDecl());
decl->setLexicalDeclContext(decl->getASTContext().getTranslationUnitDecl());
}
bool ChainPassesThrough(clang::Decl *decl,
clang::DeclContext *base,
clang::DeclContext *(clang::Decl::*contextFromDecl)(),
clang::DeclContext *(clang::DeclContext::*contextFromContext)())
{
for (DeclContext *decl_ctx = (decl->*contextFromDecl)();
decl_ctx;
decl_ctx = (decl_ctx->*contextFromContext)())
{
if (decl_ctx == base)
{
return true;
}
}
return false;
}
clang::Decl *GetEscapedChild(clang::Decl *decl, clang::DeclContext *base = nullptr)
{
if (base)
{
// decl's DeclContext chains must pass through base.
if (!ChainPassesThrough(decl, base, &clang::Decl::getDeclContext, &clang::DeclContext::getParent) ||
!ChainPassesThrough(decl, base, &clang::Decl::getLexicalDeclContext, &clang::DeclContext::getLexicalParent))
{
return decl;
}
}
else
{
base = clang::dyn_cast<clang::DeclContext>(decl);
if (!base)
{
return nullptr;
}
}
if (clang::DeclContext *context = clang::dyn_cast<clang::DeclContext>(decl))
{
for (clang::Decl *decl : context->decls())
{
if (clang::Decl *escaped_child = GetEscapedChild(decl))
{
return escaped_child;
}
}
}
return nullptr;
}
void Override(clang::Decl *decl)
{
if (clang::Decl *escaped_child = GetEscapedChild(decl))
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
if (log)
log->Printf(" [ClangASTImporter] DeclContextOverride couldn't override (%sDecl*)%p - its child (%sDecl*)%p escapes",
decl->getDeclKindName(), static_cast<void*>(decl),
escaped_child->getDeclKindName(), static_cast<void*>(escaped_child));
lldbassert(0 && "Couldn't override!");
}
OverrideOne(decl);
}
public:
DeclContextOverride()
{
}
void OverrideAllDeclsFromContainingFunction(clang::Decl *decl)
{
for (DeclContext *decl_context = decl->getLexicalDeclContext();
decl_context;
decl_context = decl_context->getLexicalParent())
{
DeclContext *redecl_context = decl_context->getRedeclContext();
if (llvm::isa<FunctionDecl>(redecl_context) &&
llvm::isa<TranslationUnitDecl>(redecl_context->getLexicalParent()))
{
for (clang::Decl *child_decl : decl_context->decls())
{
Override(child_decl);
}
}
}
}
~DeclContextOverride()
{
for (const std::pair<clang::Decl *, Backup> &backup : m_backups)
{
backup.first->setDeclContext(backup.second.decl_context);
backup.first->setLexicalDeclContext(backup.second.lexical_decl_context);
}
}
};
Rename clang_type_t to opaque_compiler_type_t. Summary: This is no longer related to Clang and is just an opaque pointer to data for a compiler type. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D13039 llvm-svn: 248288
2015-09-23 01:04:24 +08:00
lldb::opaque_compiler_type_t
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
ClangASTImporter::DeportType (clang::ASTContext *dst_ctx,
clang::ASTContext *src_ctx,
Rename clang_type_t to opaque_compiler_type_t. Summary: This is no longer related to Clang and is just an opaque pointer to data for a compiler type. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D13039 llvm-svn: 248288
2015-09-23 01:04:24 +08:00
lldb::opaque_compiler_type_t type)
Improved logging for deported types in the ClangASTImporter. llvm-svn: 246666
2015-09-03 00:39:23 +08:00
{
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
if (log)
log->Printf(" [ClangASTImporter] DeportType called on (%sType*)0x%llx from (ASTContext*)%p to (ASTContext*)%p",
QualType::getFromOpaquePtr(type)->getTypeClassName(), (unsigned long long)type,
static_cast<void*>(src_ctx),
static_cast<void*>(dst_ctx));
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
if (!minion_sp)
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
std::set<NamedDecl *> decls_to_deport;
std::set<NamedDecl *> decls_already_deported;
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
Fixed a serious bug in DeportType where the types could retain DeclContexts that pointed into the artificial function constructed for the expression. I now make anything that pointed to the function as its DeclContext be global while the copy occurs; afterward I restored the old DeclContext. Added a testcase that make sure that this works properly and doesn't crash anything. <rdar://problem/21049838> llvm-svn: 241695
2015-07-09 02:03:41 +08:00
DeclContextOverride decl_context_override;
if (const clang::TagType *tag_type = clang::QualType::getFromOpaquePtr(type)->getAs<TagType>())
{
decl_context_override.OverrideAllDeclsFromContainingFunction(tag_type->getDecl());
}
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
minion_sp->InitDeportWorkQueues(&decls_to_deport,
&decls_already_deported);
Rename clang_type_t to opaque_compiler_type_t. Summary: This is no longer related to Clang and is just an opaque pointer to data for a compiler type. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D13039 llvm-svn: 248288
2015-09-23 01:04:24 +08:00
lldb::opaque_compiler_type_t result = CopyType(dst_ctx, src_ctx, type);
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
minion_sp->ExecuteDeportWorkQueues();
if (!result)
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
return result;
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
Updated Clang to take an enhancement to the way we handle Objective-C method calls. Currently, LLDB treats the result of an Objective-C method as unknown if the type information doesn't have the method's signature. Now Clang can cast the result to id if it isn't explicitly cast. I also added a test case for this, as well as a fix for a type import problem that this feature exposed. llvm-svn: 146756
2011-12-17 05:06:35 +08:00
}
As part of the work to make Objective-C type information from symbols more accessible, I have added a second map to the ClangASTImporter: the ObjCInterfaceMetaMap. This map keeps track of all type definitions found for a particular Objective-C interface, allowing the ClangASTSource to refer to all possible sources when looking for method definitions. There is a bug in lookup that I still need to figure out, but after that we should be able to report full method information for Objective-C classes shown in symbols. Also fixed some errors I ran into when enabling the maps for the persistent type store. The persistent type store previously did not use the ClangASTImporter to import types, instead using ASTImporters that got allocated each time a type needed copying. To support the requirements of the persistent type store -- namely, that types must be copied, completed, and then completely severed from their origin in the parser's AST context (which will go away) -- I added a new function called DeportType which severs all these connections. llvm-svn: 145914
2011-12-06 11:41:14 +08:00
clang::Decl *
ClangASTImporter::DeportDecl (clang::ASTContext *dst_ctx,
clang::ASTContext *src_ctx,
clang::Decl *decl)
{
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed some problems with type deportation: - made sure we tell Clang not to try to complete the type since it can't be completed from its origin any more; and - fixed a silly bug where we tried to forget about the original decl's origins rather than the deported decl's origin. These produced some crashes in ptr_refs, especially under libgmalloc. <rdar://problem/13256150> llvm-svn: 176233
2013-02-28 11:12:58 +08:00
if (log)
Improved logging for deported types in the ClangASTImporter. llvm-svn: 246666
2015-09-03 00:39:23 +08:00
log->Printf(" [ClangASTImporter] DeportDecl called on (%sDecl*)%p from (ASTContext*)%p to (ASTContext*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
decl->getDeclKindName(), static_cast<void*>(decl),
static_cast<void*>(src_ctx),
static_cast<void*>(dst_ctx));
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
MinionSP minion_sp (GetMinion (dst_ctx, src_ctx));
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
if (!minion_sp)
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
std::set<NamedDecl *> decls_to_deport;
std::set<NamedDecl *> decls_already_deported;
Fixed a serious bug in DeportType where the types could retain DeclContexts that pointed into the artificial function constructed for the expression. I now make anything that pointed to the function as its DeclContext be global while the copy occurs; afterward I restored the old DeclContext. Added a testcase that make sure that this works properly and doesn't crash anything. <rdar://problem/21049838> llvm-svn: 241695
2015-07-09 02:03:41 +08:00
DeclContextOverride decl_context_override;
decl_context_override.OverrideAllDeclsFromContainingFunction(decl);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
minion_sp->InitDeportWorkQueues(&decls_to_deport,
&decls_already_deported);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
clang::Decl *result = CopyDecl(dst_ctx, src_ctx, decl);
minion_sp->ExecuteDeportWorkQueues();
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
if (!result)
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed some problems with type deportation: - made sure we tell Clang not to try to complete the type since it can't be completed from its origin any more; and - fixed a silly bug where we tried to forget about the original decl's origins rather than the deported decl's origin. These produced some crashes in ptr_refs, especially under libgmalloc. <rdar://problem/13256150> llvm-svn: 176233
2013-02-28 11:12:58 +08:00
if (log)
log->Printf(" [ClangASTImporter] DeportDecl deported (%sDecl*)%p to (%sDecl*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
decl->getDeclKindName(), static_cast<void*>(decl),
result->getDeclKindName(), static_cast<void*>(result));
As part of the work to make Objective-C type information from symbols more accessible, I have added a second map to the ClangASTImporter: the ObjCInterfaceMetaMap. This map keeps track of all type definitions found for a particular Objective-C interface, allowing the ClangASTSource to refer to all possible sources when looking for method definitions. There is a bug in lookup that I still need to figure out, but after that we should be able to report full method information for Objective-C classes shown in symbols. Also fixed some errors I ran into when enabling the maps for the persistent type store. The persistent type store previously did not use the ClangASTImporter to import types, instead using ASTImporters that got allocated each time a type needed copying. To support the requirements of the persistent type store -- namely, that types must be copied, completed, and then completely severed from their origin in the parser's AST context (which will go away) -- I added a new function called DeportType which severs all these connections. llvm-svn: 145914
2011-12-06 11:41:14 +08:00
return result;
}
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
void
ClangASTImporter::CompleteDecl (clang::Decl *decl)
{
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
if (log)
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
log->Printf(" [ClangASTImporter] CompleteDecl called on (%sDecl*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
decl->getDeclKindName(), static_cast<void*>(decl));
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
if (ObjCInterfaceDecl *interface_decl = dyn_cast<ObjCInterfaceDecl>(decl))
{
if (!interface_decl->getDefinition())
{
interface_decl->startDefinition();
CompleteObjCInterfaceDecl(interface_decl);
}
}
Ran the static analyzer on the codebase and found a few things. llvm-svn: 160338
2012-07-17 11:23:13 +08:00
else if (ObjCProtocolDecl *protocol_decl = dyn_cast<ObjCProtocolDecl>(decl))
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
{
if (!protocol_decl->getDefinition())
protocol_decl->startDefinition();
}
else if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
{
if (!tag_decl->getDefinition() && !tag_decl->isBeingDefined())
{
tag_decl->startDefinition();
CompleteTagDecl(tag_decl);
tag_decl->setCompleteDefinition(true);
}
}
<rdar://problem/11082392> Fixed an issue that could cause circular type parsing that will assert and kill LLDB. Prior to this fix the DWARF parser would always create class types and not start their definitions (for both C++ and ObjC classes) until we were asked to complete the class later. When we had cases like: class A { class B { }; }; We would alway try to complete A before specifying "A" as the decl context for B. Turns out we can just start the definition and still not complete the class since we can check the TagDecl::isCompleteDefinition() function. This only works for C++ types. This means we will not be pulling in the full definition of parent classes all the time and should help with our memory consumption and also reduce the amount of debug info we have to parse. I also reduced redundant code that was checking in a lldb::clang_type_t was a possible C++ dynamic type since it was still completing the type, just to see if it was dynamic. This was fixed in another function that was checking for a type being dynamic as an ObjC or a C++ type, but there was dedicated fucntion for C++ that we missed. llvm-svn: 153713
2012-03-30 08:51:13 +08:00
else
{
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
assert (0 && "CompleteDecl called on a Decl that can't be completed");
}
}
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
bool
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
ClangASTImporter::CompleteTagDecl (clang::TagDecl *decl)
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
{
ClangASTMetrics::RegisterDeclCompletion();
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
DeclOrigin decl_origin = GetDeclOrigin(decl);
if (!decl_origin.Valid())
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return false;
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return false;
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
MinionSP minion_sp (GetMinion(&decl->getASTContext(), decl_origin.ctx));
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (minion_sp)
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
minion_sp->ImportDefinitionTo(decl, decl_origin.decl);
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return true;
}
bool
ClangASTImporter::CompleteTagDeclWithOrigin(clang::TagDecl *decl, clang::TagDecl *origin_decl)
{
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
ClangASTMetrics::RegisterDeclCompletion();
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
clang::ASTContext *origin_ast_ctx = &origin_decl->getASTContext();
if (!ClangASTContext::GetCompleteDecl(origin_ast_ctx, origin_decl))
return false;
MinionSP minion_sp (GetMinion(&decl->getASTContext(), origin_ast_ctx));
if (minion_sp)
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
minion_sp->ImportDefinitionTo(decl, origin_decl);
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
OriginMap &origins = context_md->m_origins;
origins[decl] = DeclOrigin(origin_ast_ctx, origin_decl);
return true;
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
}
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
bool
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
ClangASTImporter::CompleteObjCInterfaceDecl (clang::ObjCInterfaceDecl *interface_decl)
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
{
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
ClangASTMetrics::RegisterDeclCompletion();
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
DeclOrigin decl_origin = GetDeclOrigin(interface_decl);
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (!decl_origin.Valid())
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return false;
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (!ClangASTContext::GetCompleteDecl(decl_origin.ctx, decl_origin.decl))
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return false;
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
MinionSP minion_sp (GetMinion(&interface_decl->getASTContext(), decl_origin.ctx));
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
Fixed an issue that was causing us to crash when evaluating expressions for objective C or C++ methods when "self" or "this" were in scope, but had invalid locations in a DWARF location list. The lack of a valid value caused us to use an invalid type value and then we tried to import that invalid value and we would crash. llvm-svn: 134518
2011-07-07 02:55:08 +08:00
if (minion_sp)
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
minion_sp->ImportDefinitionTo(interface_decl, decl_origin.decl);
Be sure to complete base classes when importing them. llvm-svn: 234771
2015-04-14 02:32:54 +08:00
if (ObjCInterfaceDecl *super_class = interface_decl->getSuperClass())
RequireCompleteType(clang::QualType(super_class->getTypeForDecl(), 0));
If the expression parser is unable to complete a TagDecl in the context in which it was originally found, the expression parser now goes hunting for it in all modules (in the appropriate namespace, if applicable). This means that forward-declared types that exist in another shared library will now be resolved correctly. Added a test case to cover this. The test case also tests "frame variable," which does not have this functionality yet. llvm-svn: 146204
2011-12-09 07:45:45 +08:00
return true;
This commit adds broad architectural support for hierarchical inspection of namespaces in the expression parser. ClangExpressionDeclMap hitherto reported that namespaces had been completely imported, even though the namespaces are returned empty. To deal with this situation, ClangASTSource was recently extended with an API to complete incomplete type definitions, and, for greater efficiency, to complete these definitions partially, returning only those objects that have a given name. This commit supports these APIs on LLDB's side, and uses it to provide information on types resident in namespaces. Namespaces are now imported as they were -- that is to say, empty -- but with minimal import mode on. This means that Clang will come back and request their contents by name as needed. We now respond with information on the contained types; this will be followed soon by information on functions and variables. llvm-svn: 133852
2011-06-25 08:44:06 +08:00
}
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
Trying to submit 254476 one more time. This implement -gmodule debugging support. It was previously reverted due to issues that showed up only on linux. I was able to reproduce these issues and fix the underlying cause. So this is the same patch as 254476 with the following two fixes: - Fix not trying to complete classes that don't have external sources - Fix ClangASTSource::CompleteType() to check the decl context of types that it finds by basename to ensure we don't complete a type "S" with a type like "std::S". Before this fix ClangASTSource::CompleteType() would accept _any_ type that had a matching basename and copy it into the other type. <rdar://problem/22992457> llvm-svn: 254980
2015-12-08 09:02:08 +08:00
bool
ClangASTImporter::CompleteAndFetchChildren (clang::QualType type)
{
if (!RequireCompleteType(type))
return false;
if (const TagType *tag_type = type->getAs<TagType>())
{
TagDecl *tag_decl = tag_type->getDecl();
DeclOrigin decl_origin = GetDeclOrigin(tag_decl);
if (!decl_origin.Valid())
return false;
MinionSP minion_sp (GetMinion(&tag_decl->getASTContext(), decl_origin.ctx));
TagDecl *origin_tag_decl = llvm::dyn_cast<TagDecl>(decl_origin.decl);
for (Decl *origin_child_decl : origin_tag_decl->decls())
{
minion_sp->Import(origin_child_decl);
}
if (RecordDecl *record_decl = dyn_cast<RecordDecl>(origin_tag_decl))
{
record_decl->setHasLoadedFieldsFromExternalStorage(true);
}
return true;
}
if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>())
{
if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface())
{
DeclOrigin decl_origin = GetDeclOrigin(objc_interface_decl);
if (!decl_origin.Valid())
return false;
MinionSP minion_sp (GetMinion(&objc_interface_decl->getASTContext(), decl_origin.ctx));
ObjCInterfaceDecl *origin_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(decl_origin.decl);
for (Decl *origin_child_decl : origin_interface_decl->decls())
{
minion_sp->Import(origin_child_decl);
}
return true;
}
else
{
return false;
}
}
return true;
}
Modified the way we report fields of records. Clang requires them to have complete types, but we were previously only completing them if they were of tag or Objective-C object types. I have implemented a method on the ASTImporter whose job is to complete a type. It handles not only the cases mentioned above, but also array and atomic types. <rdar://problem/13446777> llvm-svn: 177672
2013-03-22 06:15:41 +08:00
bool
ClangASTImporter::RequireCompleteType (clang::QualType type)
{
if (type.isNull())
return false;
if (const TagType *tag_type = type->getAs<TagType>())
{
Fix resolution of certain recursive types. Summary: If a struct type S has a member T that has a member that is a function that returns a typedef of S* the respective field would be duplicated, which caused an assert down the line in RecordLayoutBuilder. This patch adds a check that removes the possibility of trying to resolve the same type twice within the same callstack. This commit also adds unit tests for these failures. Fixes https://llvm.org/bugs/show_bug.cgi?id=20486. Patch by Cristian Hancila. Test Plan: Run unit tests. Reviewers: clayborg spyffe Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D8561 llvm-svn: 234441
2015-04-09 05:52:45 +08:00
TagDecl *tag_decl = tag_type->getDecl();
if (tag_decl->getDefinition() || tag_decl->isBeingDefined())
return true;
return CompleteTagDecl(tag_decl);
Modified the way we report fields of records. Clang requires them to have complete types, but we were previously only completing them if they were of tag or Objective-C object types. I have implemented a method on the ASTImporter whose job is to complete a type. It handles not only the cases mentioned above, but also array and atomic types. <rdar://problem/13446777> llvm-svn: 177672
2013-03-22 06:15:41 +08:00
}
if (const ObjCObjectType *objc_object_type = type->getAs<ObjCObjectType>())
{
if (ObjCInterfaceDecl *objc_interface_decl = objc_object_type->getInterface())
return CompleteObjCInterfaceDecl(objc_interface_decl);
else
return false;
}
if (const ArrayType *array_type = type->getAsArrayTypeUnsafe())
{
return RequireCompleteType(array_type->getElementType());
}
if (const AtomicType *atomic_type = type->getAs<AtomicType>())
{
return RequireCompleteType(atomic_type->getPointeeType());
}
return true;
}
This is the first phase of supporting the DW_AT_object_pointer tag. I expanded the decl metadata so it could hold this information, and then used it to look up unfound names in the object pointer if it exists. This gets "frame var" to work for unqualified references to ivars captured in blocks. But the expression parser is ignoring this information still. llvm-svn: 166860
2012-10-27 10:54:13 +08:00
ClangASTMetadata *
Added a mechanism for keeping track of where in the debug information individual Decls came from. We've had a metadata infrastructure for a while, which was intended to solve a problem we've since dealt with in a different way. (It was meant to keep track of which definition of an Objective-C class was the "true" definition, but we now find it by searching the symbols for the class symbol.) The metadata is attached to the ExternalASTSource, which means it has a one-to-one correspondence with AST contexts. I've repurposed the metadata infrastructure to hold the object file and DIE offset for the DWARF information corresponding to a Decl. There are methods in ClangASTContext that get and set this metadata, and the ClangASTImporter is capable of tracking down the metadata for Decls that have been copied out of the debug information into the parser's AST context without using any additional memory. To see the metadata, you just have to enable the expression log: - (lldb) log enable lldb expr - and watch the import messages. The high 32 bits of the metadata indicate the index of the object file in its containing DWARFDebugMap; I have also added a log which you can use to track that mapping: - (lldb) log enable dwarf map - This adds 64 bits per Decl, which in my testing hasn't turned out to be very much (debugging Clang produces around 6500 Decls in my tests). To track how much data is being consumed, I've also added a global variable g_TotalSizeOfMetadata which tracks the total number of Decls that have metadata in all active AST contexts. Right now this metadata is enormously useful for tracking down bugs in the debug info parser. In the future I also want to use this information to provide more intelligent error messages instead of printing empty source lines wherever Clang refers to the location where something is defined. llvm-svn: 154634
2012-04-13 08:10:03 +08:00
ClangASTImporter::GetDeclMetadata (const clang::Decl *decl)
{
DeclOrigin decl_origin = GetDeclOrigin(decl);
if (decl_origin.Valid())
Don't use a "uintptr_t" for the metadata key, use a "void *". This removes all of the casts that were being used and cleans the code up a bit. Also added the ability to dump the metadata. llvm-svn: 178113
2013-03-27 09:48:02 +08:00
return ClangASTContext::GetMetadata(decl_origin.ctx, decl_origin.decl);
Added a mechanism for keeping track of where in the debug information individual Decls came from. We've had a metadata infrastructure for a while, which was intended to solve a problem we've since dealt with in a different way. (It was meant to keep track of which definition of an Objective-C class was the "true" definition, but we now find it by searching the symbols for the class symbol.) The metadata is attached to the ExternalASTSource, which means it has a one-to-one correspondence with AST contexts. I've repurposed the metadata infrastructure to hold the object file and DIE offset for the DWARF information corresponding to a Decl. There are methods in ClangASTContext that get and set this metadata, and the ClangASTImporter is capable of tracking down the metadata for Decls that have been copied out of the debug information into the parser's AST context without using any additional memory. To see the metadata, you just have to enable the expression log: - (lldb) log enable lldb expr - and watch the import messages. The high 32 bits of the metadata indicate the index of the object file in its containing DWARFDebugMap; I have also added a log which you can use to track that mapping: - (lldb) log enable dwarf map - This adds 64 bits per Decl, which in my testing hasn't turned out to be very much (debugging Clang produces around 6500 Decls in my tests). To track how much data is being consumed, I've also added a global variable g_TotalSizeOfMetadata which tracks the total number of Decls that have metadata in all active AST contexts. Right now this metadata is enormously useful for tracking down bugs in the debug info parser. In the future I also want to use this information to provide more intelligent error messages instead of printing empty source lines wherever Clang refers to the location where something is defined. llvm-svn: 154634
2012-04-13 08:10:03 +08:00
else
Don't use a "uintptr_t" for the metadata key, use a "void *". This removes all of the casts that were being used and cleans the code up a bit. Also added the ability to dump the metadata. llvm-svn: 178113
2013-03-27 09:48:02 +08:00
return ClangASTContext::GetMetadata(&decl->getASTContext(), decl);
Added a mechanism for keeping track of where in the debug information individual Decls came from. We've had a metadata infrastructure for a while, which was intended to solve a problem we've since dealt with in a different way. (It was meant to keep track of which definition of an Objective-C class was the "true" definition, but we now find it by searching the symbols for the class symbol.) The metadata is attached to the ExternalASTSource, which means it has a one-to-one correspondence with AST contexts. I've repurposed the metadata infrastructure to hold the object file and DIE offset for the DWARF information corresponding to a Decl. There are methods in ClangASTContext that get and set this metadata, and the ClangASTImporter is capable of tracking down the metadata for Decls that have been copied out of the debug information into the parser's AST context without using any additional memory. To see the metadata, you just have to enable the expression log: - (lldb) log enable lldb expr - and watch the import messages. The high 32 bits of the metadata indicate the index of the object file in its containing DWARFDebugMap; I have also added a log which you can use to track that mapping: - (lldb) log enable dwarf map - This adds 64 bits per Decl, which in my testing hasn't turned out to be very much (debugging Clang produces around 6500 Decls in my tests). To track how much data is being consumed, I've also added a global variable g_TotalSizeOfMetadata which tracks the total number of Decls that have metadata in all active AST contexts. Right now this metadata is enormously useful for tracking down bugs in the debug info parser. In the future I also want to use this information to provide more intelligent error messages instead of printing empty source lines wherever Clang refers to the location where something is defined. llvm-svn: 154634
2012-04-13 08:10:03 +08:00
}
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
ClangASTImporter::DeclOrigin
ClangASTImporter::GetDeclOrigin(const clang::Decl *decl)
{
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
OriginMap &origins = context_md->m_origins;
OriginMap::iterator iter = origins.find(decl);
if (iter != origins.end())
return iter->second;
else
return DeclOrigin();
}
Fixed a problem where persistent variables did not correctly store the contents of Objective-C classes. This was due to a combination of factors: 1) Types were only being completed if we were looking inside them for specific ivars (using FindExternalVisibleDeclsByName). We now look the complete type up at every FindExternalLexicalDecls. 2) Even if the types were completed properly, ValueObjectConstResult overrode the type of every ValueObject using the complete type for its class from the debug information. Superclasses of complete classes are not guaranteed to be complete. Although "frame variable" uses the debug information, the expression parser does now piece together complete types at every level (as described in Bullet 1), so I provided a way for the expression parser to prevent overriding. 3) Type sizes were being miscomputed by ClangASTContext. It ignored the ISA pointer and only counted fields. We now correctly count the ISA in the size of an object. <rdar://problem/12315386> llvm-svn: 164333
2012-09-21 07:21:16 +08:00
void
ClangASTImporter::SetDeclOrigin (const clang::Decl *decl, clang::Decl *original_decl)
{
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
OriginMap &origins = context_md->m_origins;
OriginMap::iterator iter = origins.find(decl);
if (iter != origins.end())
{
iter->second.decl = original_decl;
iter->second.ctx = &original_decl->getASTContext();
}
else
{
origins[decl] = DeclOrigin(&original_decl->getASTContext(), original_decl);
}
}
void
Implemented a namespace map that allows searching of namespaces (only in the modules where they've been found) for entities inside those namespaces. For each NamespaceDecl that has been imported into the parser, we maintain a map containing [ModuleSP, ClangNamespaceDecl] pairs in the ASTImporter. This map has one entry for each module in which the namespace has been found. When we later scan for an entity inside a namespace, we search only the modules in which that namespace was found. Also made a small whitespace fix in ClangExpressionParser.cpp. llvm-svn: 141748
2011-10-12 08:12:34 +08:00
ClangASTImporter::RegisterNamespaceMap(const clang::NamespaceDecl *decl,
NamespaceMapSP &namespace_map)
{
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
context_md->m_namespace_maps[decl] = namespace_map;
Implemented a namespace map that allows searching of namespaces (only in the modules where they've been found) for entities inside those namespaces. For each NamespaceDecl that has been imported into the parser, we maintain a map containing [ModuleSP, ClangNamespaceDecl] pairs in the ASTImporter. This map has one entry for each module in which the namespace has been found. When we later scan for an entity inside a namespace, we search only the modules in which that namespace was found. Also made a small whitespace fix in ClangExpressionParser.cpp. llvm-svn: 141748
2011-10-12 08:12:34 +08:00
}
ClangASTImporter::NamespaceMapSP
ClangASTImporter::GetNamespaceMap(const clang::NamespaceDecl *decl)
{
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
NamespaceMetaMap &namespace_maps = context_md->m_namespace_maps;
Implemented a namespace map that allows searching of namespaces (only in the modules where they've been found) for entities inside those namespaces. For each NamespaceDecl that has been imported into the parser, we maintain a map containing [ModuleSP, ClangNamespaceDecl] pairs in the ASTImporter. This map has one entry for each module in which the namespace has been found. When we later scan for an entity inside a namespace, we search only the modules in which that namespace was found. Also made a small whitespace fix in ClangExpressionParser.cpp. llvm-svn: 141748
2011-10-12 08:12:34 +08:00
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
NamespaceMetaMap::iterator iter = namespace_maps.find(decl);
if (iter != namespace_maps.end())
Implemented a namespace map that allows searching of namespaces (only in the modules where they've been found) for entities inside those namespaces. For each NamespaceDecl that has been imported into the parser, we maintain a map containing [ModuleSP, ClangNamespaceDecl] pairs in the ASTImporter. This map has one entry for each module in which the namespace has been found. When we later scan for an entity inside a namespace, we search only the modules in which that namespace was found. Also made a small whitespace fix in ClangExpressionParser.cpp. llvm-svn: 141748
2011-10-12 08:12:34 +08:00
return iter->second;
else
return NamespaceMapSP();
}
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
void
ClangASTImporter::BuildNamespaceMap(const clang::NamespaceDecl *decl)
{
Bunch of cleanups for warnings found by the llvm static analyzer. llvm-svn: 165808
2012-10-13 01:34:26 +08:00
assert (decl);
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
ASTContextMetadataSP context_md = GetContextMetadata(&decl->getASTContext());
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
const DeclContext *parent_context = decl->getDeclContext();
const NamespaceDecl *parent_namespace = dyn_cast<NamespaceDecl>(parent_context);
NamespaceMapSP parent_map;
if (parent_namespace)
parent_map = GetNamespaceMap(parent_namespace);
NamespaceMapSP new_map;
new_map.reset(new NamespaceMap);
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
if (context_md->m_map_completer)
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
{
std::string namespace_string = decl->getDeclName().getAsString();
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
context_md->m_map_completer->CompleteNamespaceMap (new_map, ConstString(namespace_string.c_str()), parent_map);
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
}
As part of the work to make Objective-C type information from symbols more accessible, I have added a second map to the ClangASTImporter: the ObjCInterfaceMetaMap. This map keeps track of all type definitions found for a particular Objective-C interface, allowing the ClangASTSource to refer to all possible sources when looking for method definitions. There is a bug in lookup that I still need to figure out, but after that we should be able to report full method information for Objective-C classes shown in symbols. Also fixed some errors I ran into when enabling the maps for the persistent type store. The persistent type store previously did not use the ClangASTImporter to import types, instead using ASTImporters that got allocated each time a type needed copying. To support the requirements of the persistent type store -- namely, that types must be copied, completed, and then completely severed from their origin in the parser's AST context (which will go away) -- I added a new function called DeportType which severs all these connections. llvm-svn: 145914
2011-12-06 11:41:14 +08:00
context_md->m_namespace_maps[decl] = new_map;
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
}
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
void
Changed ClangASTImporter to allow finer-grained management of what allocations remain after an expression finishes executing. This saves around 2.5KiB per expression for simple expressions. llvm-svn: 145342
2011-11-29 08:42:02 +08:00
ClangASTImporter::ForgetDestination (clang::ASTContext *dst_ast)
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
{
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
if (log)
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
log->Printf(" [ClangASTImporter] Forgetting destination (ASTContext*)%p",
static_cast<void*>(dst_ast));
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
Changed the ClangASTImporter to store metadata for each AST context it knows about in a single object. This makes it faster to look up the appropriate ASTImpoter for a given ASTContext pair and also makes it much easier to delete all metadata for a given AST context. In the future, this fix will allow the ClangASTImporter to propagate completion information between the metadata for different AST contexts as its minions move AST objects around. llvm-svn: 144835
2011-11-17 05:40:57 +08:00
m_metadata_map.erase(dst_ast);
I made the ClangASTImporter owned by the target rather than individually on behalf of each ASTContext. This allows the ASTImporter to know about all containers of types, which will let it be smarter about forwarding information about type origins. That means that the following sequence of steps will be possible (after a few more changes): - Import a type from a Module's ASTContext into an expression parser ASTContext, tracking its origin information -- this works now. - Because the result of the expression uses that type, import it from the expression parser ASTContext into the Target's scratch AST context, forwarding the origin information -- this needs to be added. - For a later expression that uses the result, import the type from the Target's scratch AST context, still forwarding origin information -- this also needs to be added. - Use the intact origin information to complete the type as needed -- this works now if the origin information is present. To this end, I made the following changes: - ASTImporter top-level copy functions now require both a source and a destination AST context parameter. - The ASTImporter now knows how to purge records related to an ASTContext that is going away. - The Target now owns and creates the ASTImporter whenever the main executable changes or (in the absence of a main executable) on demand. llvm-svn: 144802
2011-11-17 02:20:47 +08:00
}
Changed ClangASTImporter to allow finer-grained management of what allocations remain after an expression finishes executing. This saves around 2.5KiB per expression for simple expressions. llvm-svn: 145342
2011-11-29 08:42:02 +08:00
void
ClangASTImporter::ForgetSource (clang::ASTContext *dst_ast, clang::ASTContext *src_ast)
{
ASTContextMetadataSP md = MaybeGetContextMetadata (dst_ast);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
if (log)
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
log->Printf(" [ClangASTImporter] Forgetting source->dest (ASTContext*)%p->(ASTContext*)%p",
static_cast<void*>(src_ast), static_cast<void*>(dst_ast));
Changed ClangASTImporter to allow finer-grained management of what allocations remain after an expression finishes executing. This saves around 2.5KiB per expression for simple expressions. llvm-svn: 145342
2011-11-29 08:42:02 +08:00
if (!md)
return;
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Changed ClangASTImporter to allow finer-grained management of what allocations remain after an expression finishes executing. This saves around 2.5KiB per expression for simple expressions. llvm-svn: 145342
2011-11-29 08:42:02 +08:00
md->m_minions.erase(src_ast);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Changed ClangASTImporter to allow finer-grained management of what allocations remain after an expression finishes executing. This saves around 2.5KiB per expression for simple expressions. llvm-svn: 145342
2011-11-29 08:42:02 +08:00
for (OriginMap::iterator iter = md->m_origins.begin();
iter != md->m_origins.end();
)
{
if (iter->second.ctx == src_ast)
md->m_origins.erase(iter++);
else
++iter;
}
}
As part of the work to make Objective-C type information from symbols more accessible, I have added a second map to the ClangASTImporter: the ObjCInterfaceMetaMap. This map keeps track of all type definitions found for a particular Objective-C interface, allowing the ClangASTSource to refer to all possible sources when looking for method definitions. There is a bug in lookup that I still need to figure out, but after that we should be able to report full method information for Objective-C classes shown in symbols. Also fixed some errors I ran into when enabling the maps for the persistent type store. The persistent type store previously did not use the ClangASTImporter to import types, instead using ASTImporters that got allocated each time a type needed copying. To support the requirements of the persistent type store -- namely, that types must be copied, completed, and then completely severed from their origin in the parser's AST context (which will go away) -- I added a new function called DeportType which severs all these connections. llvm-svn: 145914
2011-12-06 11:41:14 +08:00
ClangASTImporter::MapCompleter::~MapCompleter ()
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
{
return;
}
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
void
ClangASTImporter::Minion::InitDeportWorkQueues (std::set<clang::NamedDecl *> *decls_to_deport,
std::set<clang::NamedDecl *> *decls_already_deported)
{
Removed comments that suggested that asserts in the ClangASTImporter should be debug-only. This is not the case; when they fire we are about to crash or do something horrible anyway, so they should stay in. llvm-svn: 246667
2015-09-03 00:40:59 +08:00
assert(!m_decls_to_deport);
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
assert(!m_decls_already_deported);
m_decls_to_deport = decls_to_deport;
m_decls_already_deported = decls_already_deported;
}
void
ClangASTImporter::Minion::ExecuteDeportWorkQueues ()
{
Removed comments that suggested that asserts in the ClangASTImporter should be debug-only. This is not the case; when they fire we are about to crash or do something horrible anyway, so they should stay in. llvm-svn: 246667
2015-09-03 00:40:59 +08:00
assert(m_decls_to_deport);
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
assert(m_decls_already_deported);
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&getToContext());
while (!m_decls_to_deport->empty())
{
NamedDecl *decl = *m_decls_to_deport->begin();
m_decls_already_deported->insert(decl);
m_decls_to_deport->erase(decl);
DeclOrigin &origin = to_context_md->m_origins[decl];
Add UNUSED_IF_ASSERT_DISABLED and apply it. Summary: This replaces (void)x; usages where they x was subsequently involved in an assertion with this macro to make the intent more clear. Reviewers: clayborg Subscribers: lldb-commits Differential Revision: http://reviews.llvm.org/D11451 llvm-svn: 243074
2015-07-24 08:23:29 +08:00
UNUSED_IF_ASSERT_DISABLED(origin);
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
assert (origin.ctx == m_source_ctx); // otherwise we should never have added this
// because it doesn't need to be deported
Decl *original_decl = to_context_md->m_origins[decl].decl;
ClangASTContext::GetCompleteDecl (m_source_ctx, original_decl);
if (TagDecl *tag_decl = dyn_cast<TagDecl>(decl))
{
if (TagDecl *original_tag_decl = dyn_cast<TagDecl>(original_decl))
if (original_tag_decl->isCompleteDefinition())
ImportDefinitionTo(tag_decl, original_tag_decl);
tag_decl->setHasExternalLexicalStorage(false);
tag_decl->setHasExternalVisibleStorage(false);
}
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
else if (ObjCContainerDecl *container_decl = dyn_cast<ObjCContainerDecl>(decl))
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
{
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
container_decl->setHasExternalLexicalStorage(false);
container_decl->setHasExternalVisibleStorage(false);
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
}
to_context_md->m_origins.erase(decl);
}
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
m_decls_to_deport = nullptr;
m_decls_already_deported = nullptr;
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
}
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
void
ClangASTImporter::Minion::ImportDefinitionTo (clang::Decl *to, clang::Decl *from)
{
ASTImporter::Imported(from, to);
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
ObjCInterfaceDecl *to_objc_interface = dyn_cast<ObjCInterfaceDecl>(to);
/*
if (to_objc_interface)
to_objc_interface->startDefinition();
CXXRecordDecl *to_cxx_record = dyn_cast<CXXRecordDecl>(to);
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
if (to_cxx_record)
to_cxx_record->startDefinition();
*/
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
ImportDefinition(from);
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
Fixed a problem where Objective-C classes that were originally imported from symbols for the expression parser didn't get their superclasses set properly. llvm-svn: 148488
2012-01-20 02:23:06 +08:00
// If we're dealing with an Objective-C class, ensure that the inheritance has
// been set up correctly. The ASTImporter may not do this correctly if the
// class was originally sourced from symbols.
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
if (to_objc_interface)
Fixed a problem where Objective-C classes that were originally imported from symbols for the expression parser didn't get their superclasses set properly. llvm-svn: 148488
2012-01-20 02:23:06 +08:00
{
do
{
ObjCInterfaceDecl *to_superclass = to_objc_interface->getSuperClass();
if (to_superclass)
break; // we're not going to override it if it's set
ObjCInterfaceDecl *from_objc_interface = dyn_cast<ObjCInterfaceDecl>(from);
if (!from_objc_interface)
break;
ObjCInterfaceDecl *from_superclass = from_objc_interface->getSuperClass();
if (!from_superclass)
break;
Decl *imported_from_superclass_decl = Import(from_superclass);
if (!imported_from_superclass_decl)
break;
ObjCInterfaceDecl *imported_from_superclass = dyn_cast<ObjCInterfaceDecl>(imported_from_superclass_decl);
if (!imported_from_superclass)
break;
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
if (!to_objc_interface->hasDefinition())
to_objc_interface->startDefinition();
Fix build after recent clang interface changes llvm-svn: 241573
2015-07-07 18:11:16 +08:00
to_objc_interface->setSuperClass(
m_source_ctx->getTrivialTypeSourceInfo(m_source_ctx->getObjCInterfaceType(imported_from_superclass)));
Fixed a problem where Objective-C classes that were originally imported from symbols for the expression parser didn't get their superclasses set properly. llvm-svn: 148488
2012-01-20 02:23:06 +08:00
}
while (0);
}
I made two major improvements to the way the master AST importer imports types. - First, before importing the definition of a Decl from its source, notify the underlying importer of the source->destination mapping. Especially for anonymous strucutres that are otherwise hard to unique in the target AST context, this hint is very helpful. - When deporting a type or Decl from one ASTContext to another (deporting occurs in the case of moving result types from the parser's AST context to the result AST context), don't forget their origin if the origin is the original debug information. llvm-svn: 148152
2012-01-14 06:55:55 +08:00
}
Huge change to clean up types. A long time ago we start with clang types that were created by the symbol files and there were many functions in lldb_private::ClangASTContext that helped. Later we create ClangASTType which contains a clang::ASTContext and an opauque QualType, but we didn't switch over to fully using it. There were a lot of places where we would pass around a raw clang_type_t and also pass along a clang::ASTContext separately. This left room for error. This checkin change all type code over to use ClangASTType everywhere and I cleaned up the interfaces quite a bit. Any code that was in ClangASTContext that was type related, was moved over into ClangASTType. All code that used these types was switched over to use all of the new goodness. llvm-svn: 186130
2013-07-12 06:46:58 +08:00
clang::Decl *
ClangASTImporter::Minion::Imported (clang::Decl *from, clang::Decl *to)
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
{
Added very lightweight, statically-allocated counters for a variety of metrics associated with expression parsing. This should give some idea of how much work the expression parser is doing on Clang's behalf, and help with hopefully reducing that load over time. <rdar://problem/13210748> Audit type search/import for expressions llvm-svn: 176714
2013-03-09 04:04:57 +08:00
ClangASTMetrics::RegisterClangImport();
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
<rdar://problem/13521159> LLDB is crashing when logging is enabled from lldb-perf-clang. This has to do with the global destructor chain as the process and its threads are being torn down. All logging channels now make one and only one instance that is kept in a global pointer which is never freed. This guarantees that logging can correctly continue as the process tears itself down. llvm-svn: 178191
2013-03-28 07:08:40 +08:00
Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed a problem in the Clang AST importer where we overrode debug information as the authoritative source for type information, substituting types from the Objective-C runtime. The runtime should never be the primary source. <rdar://problem/16065049> llvm-svn: 214583
2014-08-02 06:42:38 +08:00
lldb::user_id_t user_id = LLDB_INVALID_UID;
ClangASTMetadata *metadata = m_master.GetDeclMetadata(from);
if (metadata)
user_id = metadata->GetUserID();
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
if (log)
{
if (NamedDecl *from_named_decl = dyn_cast<clang::NamedDecl>(from))
{
Fixed a crash in logging when the name of an entity imported by the ASTImporter had a NamedDecl with a name that wasn't a plain string (e.g., a selector). llvm-svn: 157488
2012-05-26 02:12:26 +08:00
std::string name_string;
llvm::raw_string_ostream name_stream(name_string);
from_named_decl->printName(name_stream);
name_stream.flush();
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Resolve printf formatting warnings on Linux: - use macros from inttypes.h for format strings instead of OS-specific types Patch from Matt Kopec! llvm-svn: 168945
2012-11-30 05:49:15 +08:00
log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p, named %s (from (Decl*)%p), metadata 0x%" PRIx64,
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
from->getDeclKindName(), static_cast<void*>(to),
name_string.c_str(), static_cast<void*>(from),
This is the first phase of supporting the DW_AT_object_pointer tag. I expanded the decl metadata so it could hold this information, and then used it to look up unfound names in the object pointer if it exists. This gets "frame var" to work for unqualified references to ivars captured in blocks. But the expression parser is ignoring this information still. llvm-svn: 166860
2012-10-27 10:54:13 +08:00
user_id);
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
}
else
{
Resolve printf formatting warnings on Linux: - use macros from inttypes.h for format strings instead of OS-specific types Patch from Matt Kopec! llvm-svn: 168945
2012-11-30 05:49:15 +08:00
log->Printf(" [ClangASTImporter] Imported (%sDecl*)%p (from (Decl*)%p), metadata 0x%" PRIx64,
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
from->getDeclKindName(), static_cast<void*>(to),
static_cast<void*>(from), user_id);
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
}
}
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&to->getASTContext());
ASTContextMetadataSP from_context_md = m_master.MaybeGetContextMetadata(m_source_ctx);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
if (from_context_md)
{
OriginMap &origins = from_context_md->m_origins;
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
OriginMap::iterator origin_iter = origins.find(from);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
if (origin_iter != origins.end())
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
{
Fixed a problem in the Clang AST importer where we overrode debug information as the authoritative source for type information, substituting types from the Objective-C runtime. The runtime should never be the primary source. <rdar://problem/16065049> llvm-svn: 214583
2014-08-02 06:42:38 +08:00
if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
user_id != LLDB_INVALID_UID)
{
Eliminated a potential infinite recursion in structure layout when the origin for a CXXRecordDecl gets pointed at that record. This can happen when a type is imported out of and then into the target's AST context without being laid out. Also added a testcase that covers this scenario. <rdar://problem/21844453> llvm-svn: 242687
2015-07-21 00:55:19 +08:00
if (origin_iter->second.ctx != &to->getASTContext())
to_context_md->m_origins[to] = origin_iter->second;
Fixed a problem in the Clang AST importer where we overrode debug information as the authoritative source for type information, substituting types from the Objective-C runtime. The runtime should never be the primary source. <rdar://problem/16065049> llvm-svn: 214583
2014-08-02 06:42:38 +08:00
}
Fixed a bug in the ASTImporter that affects types that have been imported multiple times. The discussion below uses this diagram: ASTContext A B C Decl Da Db Dc ASTImporter \-Iab-/\-Iac-/ \-----Iac----/ When a Decl D is imported from ASTContext A to ASTContext B, the ASTImporter Iab records the pair <Da, Db> in a DenseMap. That way, if Iab ever encounters Da again (for example, as the DeclContext for another Decl), it can use the imported version. This is not an optimization, it is critical: if I import the field "st_dev" as part of importing "struct stat," the field must have DeclContext equal to the parent structure or we end up with multiple different Decls containing different parts of "struct stat." "struct stat" is imported once and recorded in the DenseMap; then the ASTImporter finds that same version when looking for the DeclContext of "st_dev." The bug arises when Db is imported into another ASTContext C and ASTContext B goes away. This often occurs when LLDB produces result variables for expressions. Ibc is aware of the transport of Db to Dc, but a brand new ASTImporter, Iac, is responsible for completing Dc from its source upon request. That ASTImporter has no mappings, so it will produce a clone of Dc when attempting to import its children. That means that type completion operations on Dc will fail. The solution is to create Iac as soon as Ibc imports D from B to C, and inform Iac of the mapping between Da and Dc. This allows type completion to happen correctly. llvm-svn: 147016
2011-12-21 07:55:47 +08:00
MinionSP direct_completer = m_master.GetMinion(&to->getASTContext(), origin_iter->second.ctx);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Fixed a bug in the ASTImporter that affects types that have been imported multiple times. The discussion below uses this diagram: ASTContext A B C Decl Da Db Dc ASTImporter \-Iab-/\-Iac-/ \-----Iac----/ When a Decl D is imported from ASTContext A to ASTContext B, the ASTImporter Iab records the pair <Da, Db> in a DenseMap. That way, if Iab ever encounters Da again (for example, as the DeclContext for another Decl), it can use the imported version. This is not an optimization, it is critical: if I import the field "st_dev" as part of importing "struct stat," the field must have DeclContext equal to the parent structure or we end up with multiple different Decls containing different parts of "struct stat." "struct stat" is imported once and recorded in the DenseMap; then the ASTImporter finds that same version when looking for the DeclContext of "st_dev." The bug arises when Db is imported into another ASTContext C and ASTContext B goes away. This often occurs when LLDB produces result variables for expressions. Ibc is aware of the transport of Db to Dc, but a brand new ASTImporter, Iac, is responsible for completing Dc from its source upon request. That ASTImporter has no mappings, so it will produce a clone of Dc when attempting to import its children. That means that type completion operations on Dc will fail. The solution is to create Iac as soon as Ibc imports D from B to C, and inform Iac of the mapping between Da and Dc. This allows type completion to happen correctly. llvm-svn: 147016
2011-12-21 07:55:47 +08:00
if (direct_completer.get() != this)
direct_completer->ASTImporter::Imported(origin_iter->second.decl, to);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
if (log)
log->Printf(" [ClangASTImporter] Propagated origin (Decl*)%p/(ASTContext*)%p from (ASTContext*)%p to (ASTContext*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
static_cast<void*>(origin_iter->second.decl),
static_cast<void*>(origin_iter->second.ctx),
static_cast<void*>(&from->getASTContext()),
static_cast<void*>(&to->getASTContext()));
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
}
else
{
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
if (m_decls_to_deport && m_decls_already_deported)
{
if (isa<TagDecl>(to) || isa<ObjCInterfaceDecl>(to))
{
Trying to submit 254476 one more time. This implement -gmodule debugging support. It was previously reverted due to issues that showed up only on linux. I was able to reproduce these issues and fix the underlying cause. So this is the same patch as 254476 with the following two fixes: - Fix not trying to complete classes that don't have external sources - Fix ClangASTSource::CompleteType() to check the decl context of types that it finds by basename to ensure we don't complete a type "S" with a type like "std::S". Before this fix ClangASTSource::CompleteType() would accept _any_ type that had a matching basename and copy it into the other type. <rdar://problem/22992457> llvm-svn: 254980
2015-12-08 09:02:08 +08:00
RecordDecl *from_record_decl = dyn_cast<RecordDecl>(from);
if (from_record_decl == nullptr || from_record_decl->isInjectedClassName() == false)
{
NamedDecl *to_named_decl = dyn_cast<NamedDecl>(to);
if (!m_decls_already_deported->count(to_named_decl))
m_decls_to_deport->insert(to_named_decl);
}
Fixed the way ClangASTImporter deports types from ASTContexts that will not stay around. Before, we did this in a very half-hearted way. Now we maintain work queues of all Decls that need to be completed before the source ASTContext can go away; we then expunge their origins completely. <rdar://problem/13511875> llvm-svn: 178410
2013-03-30 10:31:21 +08:00
}
}
Fixed a problem in the Clang AST importer where we overrode debug information as the authoritative source for type information, substituting types from the Objective-C runtime. The runtime should never be the primary source. <rdar://problem/16065049> llvm-svn: 214583
2014-08-02 06:42:38 +08:00
if (to_context_md->m_origins.find(to) == to_context_md->m_origins.end() ||
user_id != LLDB_INVALID_UID)
{
to_context_md->m_origins[to] = DeclOrigin(m_source_ctx, from);
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
if (log)
log->Printf(" [ClangASTImporter] Decl has no origin information in (ASTContext*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
static_cast<void*>(&from->getASTContext()));
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
if (clang::NamespaceDecl *to_namespace = dyn_cast<clang::NamespaceDecl>(to))
{
clang::NamespaceDecl *from_namespace = dyn_cast<clang::NamespaceDecl>(from);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
NamespaceMetaMap &namespace_maps = from_context_md->m_namespace_maps;
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
NamespaceMetaMap::iterator namespace_map_iter = namespace_maps.find(from_namespace);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
if (namespace_map_iter != namespace_maps.end())
to_context_md->m_namespace_maps[to_namespace] = namespace_map_iter->second;
}
}
else
{
to_context_md->m_origins[to] = DeclOrigin (m_source_ctx, from);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
if (log)
log->Printf(" [ClangASTImporter] Sourced origin (Decl*)%p/(ASTContext*)%p into (ASTContext*)%p",
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
static_cast<void*>(from),
static_cast<void*>(m_source_ctx),
static_cast<void*>(&to->getASTContext()));
Added support to the ASTImporter for passing completion information between different AST contexts. It works like this: - If a Decl is imported from a context that has completion metadata, then that Decl is associated with the same completion information (possibly none) as the Decl it was imported from. - If a Decl is imported from a context that does not have completion metadata, then it is marked as completable by consulting the Decl and context it was imported from. llvm-svn: 144838
2011-11-17 06:23:28 +08:00
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (TagDecl *from_tag_decl = dyn_cast<TagDecl>(from))
{
TagDecl *to_tag_decl = dyn_cast<TagDecl>(to);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
to_tag_decl->setHasExternalLexicalStorage();
Brought LLDB top-of-tree into sync with LLVM/Clang top-of-tree. Removed all local patches and llvm.zip. The intent is that fron now on top-of-tree will always build against LLVM/Clang top-of-tree, and that problems building will be resolved as they occur. Stable release branches of LLDB can be constructed as needed and linked to specific release branches of LLVM/Clang. llvm-svn: 164563
2012-09-25 06:25:51 +08:00
to_tag_decl->setMustBuildLookupTable();
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
if (log)
This commit completes the rearchitecting of ClangASTSource to allow variables in the persistent variable store to know how to complete themselves from debug information. That fixes a variety of bugs during dematerialization of expression results and also makes persistent variable and result variables ($foo, $4, ...) more useful. I have also added logging improvements that make it much easier to figure out how types are moving from place to place, and made some checking a little more aggressive. The commit includes patches to Clang which are currently being integrated into Clang proper; once these fixes are in Clang top-of-tree, these patches will be removed. The patches don't fix API; rather, they fix some internal bugs in Clang's ASTImporter that were exposed when LLDB was moving types from place to place multiple times. llvm-svn: 144969
2011-11-18 11:28:09 +08:00
log->Printf(" [ClangASTImporter] To is a TagDecl - attributes %s%s [%s->%s]",
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
(to_tag_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
Added a function to ClangASTSource to service lookups for Objective-C methods by selector. Right now all it does is print log information. Also improved the logging for imported TagDecls to indicate whether or not the definition for the imported TagDecl is complete. llvm-svn: 144203
2011-11-10 03:33:21 +08:00
(to_tag_decl->hasExternalVisibleStorage() ? " Visible" : ""),
(from_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"),
(to_tag_decl->isCompleteDefinition() ? "complete" : "incomplete"));
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
if (isa<NamespaceDecl>(from))
{
NamespaceDecl *to_namespace_decl = dyn_cast<NamespaceDecl>(to);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
m_master.BuildNamespaceMap(to_namespace_decl);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Implemented an extension to the namespace map that permits a namespace map to be created and populated when the namespace is imported, not just when it is requested via FindExternalVisibleDecls(). llvm-svn: 142690
2011-10-22 06:18:07 +08:00
to_namespace_decl->setHasExternalVisibleStorage();
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
if (isa<ObjCContainerDecl>(from))
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
{
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
ObjCContainerDecl *to_container_decl = dyn_cast<ObjCContainerDecl>(to);
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
to_container_decl->setHasExternalLexicalStorage();
to_container_decl->setHasExternalVisibleStorage();
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
I have brought LLDB up-to-date with top of tree LLVM/Clang. This brings in several fixes, including: - Improvements in the Just-In-Time compiler's allocation of memory: the JIT now allocates memory in chunks of sections, improving its ability to generate relocations. I have revamped the RecordingMemoryManager to reflect these changes, as well as to get the memory allocation and data copying out fo the ClangExpressionParser code. Jim Grosbach wrote the updates to the JIT on the LLVM side. - A new ExternalASTSource interface to allow LLDB to report accurate structure layout information to Clang. Previously we could only report the sizes of fields, not their offsets. This meant that if data structures included field alignment directives, we could not communicate the necessary alignment to Clang and accesses to the data would fail. Now we can (and I have update the relevant test case). Thanks to Doug Gregor for implementing the Clang side of this fix. - The way Objective-C interfaces are completed by Clang has been made consistent with RecordDecls; with help from Doug Gregor and Greg Clayton I have ensured that this still works. - I have eliminated all local LLVM and Clang patches, committing the ones that are still relevant to LLVM and Clang as needed. I have tested the changes extensively locally, but please let me know if they cause any trouble for you. llvm-svn: 149775
2012-02-04 16:49:35 +08:00
/*to_interface_decl->setExternallyCompleted();*/
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
Pulled in a new version of LLVM/Clang to solve a variety of problems with Objective-C object completion. To go along with the LLVM/Clang-side fixes, we have a variety of Objective-C improvements. Fixes include: - It is now possible to run expressions when stopped in an Objective-C class method and have "self" act just like "self" would act in the class method itself (i.e., [self classMethod] works without casting the return type if debug info is present). To accomplish this, the expression masquerades as a class method added by a category. - Objective-C objects can now provide methods and properties and methods to Clang on demand (i.e., the ASTImporter sets hasExternalVisibleDecls on Objective-C interface objects). - Objective-C built-in types, which had long been a bone of contention (should we be using "id"? "id*"?), are now fetched correctly using accessor functions on ClangASTContext. We inhibit searches for them in the debug information. There are also a variety of logging fixes, and I made two changes to the test suite: - Enabled a test case for Objective-C properties in the current translation unit. - Added a test case for calling Objective-C class methods when stopped in a class method. llvm-svn: 144607
2011-11-15 10:11:17 +08:00
if (log)
When importing Objective-C protocols, mark them as having external decls. We already do this for Objective-C interfaces, but we never handled protocols because the DWARF didn't represent them. Nowadays, though, we can import them from modules, and we have to mark them properly. <rdar://problem/24193009> llvm-svn: 260445
2016-02-11 06:00:32 +08:00
{
if (ObjCInterfaceDecl *to_interface_decl = llvm::dyn_cast<ObjCInterfaceDecl>(to_container_decl))
{
log->Printf(" [ClangASTImporter] To is an ObjCInterfaceDecl - attributes %s%s%s",
(to_interface_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
(to_interface_decl->hasExternalVisibleStorage() ? " Visible" : ""),
(to_interface_decl->hasDefinition() ? " HasDefinition" : ""));
}
else
{
log->Printf(" [ClangASTImporter] To is an %sDecl - attributes %s%s",
((Decl*)to_container_decl)->getDeclKindName(),
(to_container_decl->hasExternalLexicalStorage() ? " Lexical" : ""),
(to_container_decl->hasExternalVisibleStorage() ? " Visible" : ""));
}
}
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
}
sweep up -Wformat warnings from gcc This is a purely mechanical change explicitly casting any parameters for printf style conversion. This cleans up the warnings emitted by gcc 4.8 on Linux. llvm-svn: 205607
2014-04-04 12:06:10 +08:00
This change brings in the latest LLVM/Clang, and completes the support in the LLDB expression parser for incomplete types. Clang now imports types lazily, and we complete those types as necessary. Changes include: - ClangASTSource now supports three APIs which it passes to ClangExpressionDeclMap. CompleteType completes a TagDecl or an ObjCInterfaceDecl when needed; FindExternalVisibleDecls finds named entities that are visible in the expression's scope; and FindExternalLexicalDecls performs a (potentially restricted) search for entities inside a lexical scope like a namespace. These changes mean that entities in namespaces should work normally. - The SymbolFileDWARF code for searching a context for a specific name is now more general, and can search arbitrary contexts. - We are continuing to adapt our calls into LLVM from interfaces that take start and end iterators when accepting multiple items to interfaces that use ArrayRef. - I have cleaned up some code, especially our use of namespaces. This change is neutral for our testsuite and greatly improves correctness for large programs (like Clang) with complicated type systems. It should also lay the groundwork for improving the expression parser's performance as we are lazier and lazier about providing type information. llvm-svn: 136555
2011-07-30 10:42:06 +08:00
return clang::ASTImporter::Imported(from, to);
While tracking down memory consumption issue a few things were needed: the ability to dump more information about modules in "target modules list". We can now dump the shared pointer reference count for modules, the pointer to the module itself (in case performance tools can help track down who has references to said pointer), and the modification time. Added "target delete [target-idx ...]" to be able to delete targets when they are no longer needed. This will help track down memory usage issues and help to resolve when module ref counts keep getting incremented. If the command gets no arguments, the currently selected target will be deleted. If any arguments are given, they must all be valid target indexes (use the "target list" command to get the current target indexes). Took care of a bunch of "no newline at end of file" warnings. TimeValue objects can now dump their time to a lldb_private::Stream object. Modified the "target modules list --global" command to not error out if there are no targets since it doesn't require a target. Fixed an issue in the MacOSX DYLD dynamic loader plug-in where if a shared library was updated on disk, we would keep using the older one, even if it was updated. Don't allow the ModuleList::GetSharedModule(...) to return an empty module. Previously we could specify a valid path on disc to a module, and specify an architecture that wasn't contained in that module and get a shared pointer to a module that wouldn't be able to return an object file or a symbol file. We now make sure an object file can be extracted prior to adding the shared pointer to the module to get added to the shared list. llvm-svn: 137196
2011-08-10 10:10:13 +08:00
}
Implemented the reverse-lookup API in the AST importer to avoid duplicate imports of anonymous structs. <rdar://problem/14421722> llvm-svn: 192327
2013-10-10 06:33:34 +08:00
clang::Decl *ClangASTImporter::Minion::GetOriginalDecl (clang::Decl *To)
{
ASTContextMetadataSP to_context_md = m_master.GetContextMetadata(&To->getASTContext());
if (!to_context_md)
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
Implemented the reverse-lookup API in the AST importer to avoid duplicate imports of anonymous structs. <rdar://problem/14421722> llvm-svn: 192327
2013-10-10 06:33:34 +08:00
OriginMap::iterator iter = to_context_md->m_origins.find(To);
if (iter == to_context_md->m_origins.end())
Switch NULL to C++11 nullptr in source/Symbol and source/Utility Patch by Robert Matusewicz llvm-svn: 206713
2014-04-20 21:17:36 +08:00
return nullptr;
Implemented the reverse-lookup API in the AST importer to avoid duplicate imports of anonymous structs. <rdar://problem/14421722> llvm-svn: 192327
2013-10-10 06:33:34 +08:00
return const_cast<clang::Decl*>(iter->second.decl);
}