maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity
llvm-project/clang/lib/Frontend/ASTUnit.cpp

2707 lines
99 KiB
C++
Raw Normal View History

Add the license part to the new source files. llvm-svn: 73825
2009-06-20 16:27:14 +08:00
//===--- ASTUnit.cpp - ASTUnit utility ------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// ASTUnit Implementation.
//
//===----------------------------------------------------------------------===//
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
#include "clang/Frontend/ASTUnit.h"
#include "clang/AST/ASTContext.h"
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
#include "clang/AST/ASTConsumer.h"
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
#include "clang/AST/DeclVisitor.h"
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
#include "clang/AST/TypeOrdering.h"
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
#include "clang/AST/StmtVisitor.h"
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
#include "clang/Driver/Compilation.h"
#include "clang/Driver/Driver.h"
#include "clang/Driver/Job.h"
Allow passing '-###' to ASTUnit::LoadFromCommandLine to print out the cc1 options. llvm-svn: 127183
2011-03-08 06:45:01 +08:00
#include "clang/Driver/ArgList.h"
#include "clang/Driver/Options.h"
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
#include "clang/Driver/Tool.h"
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
#include "clang/Frontend/CompilerInstance.h"
#include "clang/Frontend/FrontendActions.h"
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
#include "clang/Frontend/FrontendDiagnostic.h"
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
#include "clang/Frontend/FrontendOptions.h"
Switch c-index-test from clang_codeComplete() over to clang_codeCompleteAt(). This uncovered a few issues with the latter: - ASTUnit wasn't saving/restoring diagnostic state appropriately between reparses and code completions. - "Overload" completions weren't being passed through to the client llvm-svn: 116241
2010-10-12 05:37:58 +08:00
#include "clang/Frontend/Utils.h"
Rename the ASTReader header files. llvm-svn: 111474
2010-08-19 07:57:17 +08:00
#include "clang/Serialization/ASTReader.h"
Rename PCHWriter.h to ASTWriter.h llvm-svn: 111466
2010-08-19 07:56:37 +08:00
#include "clang/Serialization/ASTWriter.h"
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
#include "clang/Lex/HeaderSearch.h"
#include "clang/Lex/Preprocessor.h"
Add TargetOptions and use it when constructing targets. - This ended up being hard to factor, sorry for the large diff. - Some post-commit cleanup to come. llvm-svn: 88833
2009-11-15 14:48:46 +08:00
#include "clang/Basic/TargetOptions.h"
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
#include "clang/Basic/TargetInfo.h"
#include "clang/Basic/Diagnostic.h"
switch a few Driver APIs to use llvm::ArrayRef, cleaning up code. llvm-svn: 128142
2011-03-23 12:04:01 +08:00
#include "llvm/ADT/ArrayRef.h"
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
#include "llvm/ADT/StringExtras.h"
Move include to the proper place. No functionality change llvm-svn: 111204
2010-08-17 07:08:34 +08:00
#include "llvm/ADT/StringSet.h"
Use atomic operations for libclang's object count tracking. llvm-svn: 121073
2010-12-07 08:05:48 +08:00
#include "llvm/Support/Atomic.h"
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
#include "llvm/Support/MemoryBuffer.h"
Merge System into Support. llvm-svn: 120297
2010-11-30 02:12:39 +08:00
#include "llvm/Support/Host.h"
#include "llvm/Support/Path.h"
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
#include "llvm/Support/raw_ostream.h"
Add some timers to ASTUnit that are only enabled when the LIBCLANG_TIMING environment variable is set. llvm-svn: 109890
2010-07-31 04:58:08 +08:00
#include "llvm/Support/Timer.h"
For ASTUnit::Save, write the AST to a temporary and then rename it to the actual filename. Should avoid race conditions. Addresses rdar://9788943. llvm-svn: 135691
2011-07-22 02:44:49 +08:00
#include "llvm/Support/FileSystem.h"
[libclang] Implement ConcurrencyCheck using a recursive mutex to allow re-entrancy in the same thread. The checks are performed only in DEBUG, it becomes no-op in release mode. llvm-svn: 141582
2011-10-11 05:57:12 +08:00
#include "llvm/Support/Mutex.h"
Add mutex for accessing ASTUnit's global OnDisk data. This may be an issue as libclang could be processing multiple ASTUnit's at once. llvm-svn: 143138
2011-10-28 03:44:25 +08:00
#include "llvm/Support/MutexGuard.h"
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
#include "llvm/Support/CrashRecoveryContext.h"
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
#include <cstdlib>
Fix build on Ubuntu 10.04. llvm-svn: 109208
2010-07-23 10:15:08 +08:00
#include <cstdio>
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
#include <sys/stat.h>
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
using namespace clang;
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
using llvm::TimeRecord;
namespace {
class SimpleTimer {
bool WantTiming;
TimeRecord Start;
std::string Output;
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
public:
Disable some timing code llvm-svn: 117910
2010-11-01 21:48:43 +08:00
explicit SimpleTimer(bool WantTiming) : WantTiming(WantTiming) {
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
if (WantTiming)
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
Start = TimeRecord::getCurrentTime();
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void setOutput(const Twine &Output) {
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
if (WantTiming)
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
this->Output = Output.str();
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
}
~SimpleTimer() {
if (WantTiming) {
TimeRecord Elapsed = TimeRecord::getCurrentTime();
Elapsed -= Start;
llvm::errs() << Output << ':';
Elapsed.print(Elapsed, llvm::errs());
llvm::errs() << '\n';
}
}
};
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
struct OnDiskData {
/// \brief The file in which the precompiled preamble is stored.
std::string PreambleFile;
/// \brief Temporary files that should be removed when the ASTUnit is
/// destroyed.
SmallVector<llvm::sys::Path, 4> TemporaryFiles;
/// \brief Erase temporary files.
void CleanTemporaryFiles();
/// \brief Erase the preamble file.
void CleanPreambleFile();
/// \brief Erase temporary files and the preamble file.
void Cleanup();
};
}
Add mutex for accessing ASTUnit's global OnDisk data. This may be an issue as libclang could be processing multiple ASTUnit's at once. llvm-svn: 143138
2011-10-28 03:44:25 +08:00
static llvm::sys::SmartMutex<false> &getOnDiskMutex() {
static llvm::sys::SmartMutex<false> M(/* recursive = */ true);
return M;
}
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
static void cleanupOnDiskMapAtExit(void);
typedef llvm::DenseMap<const ASTUnit *, OnDiskData *> OnDiskDataMap;
static OnDiskDataMap &getOnDiskDataMap() {
static OnDiskDataMap M;
static bool hasRegisteredAtExit = false;
if (!hasRegisteredAtExit) {
hasRegisteredAtExit = true;
atexit(cleanupOnDiskMapAtExit);
}
return M;
}
static void cleanupOnDiskMapAtExit(void) {
Add mutex for accessing ASTUnit's global OnDisk data. This may be an issue as libclang could be processing multiple ASTUnit's at once. llvm-svn: 143138
2011-10-28 03:44:25 +08:00
// No mutex required here since we are leaving the program.
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
OnDiskDataMap &M = getOnDiskDataMap();
for (OnDiskDataMap::iterator I = M.begin(), E = M.end(); I != E; ++I) {
// We don't worry about freeing the memory associated with OnDiskDataMap.
// All we care about is erasing stale files.
I->second->Cleanup();
}
}
static OnDiskData &getOnDiskData(const ASTUnit *AU) {
Add mutex for accessing ASTUnit's global OnDisk data. This may be an issue as libclang could be processing multiple ASTUnit's at once. llvm-svn: 143138
2011-10-28 03:44:25 +08:00
// We require the mutex since we are modifying the structure of the
// DenseMap.
llvm::MutexGuard Guard(getOnDiskMutex());
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
OnDiskDataMap &M = getOnDiskDataMap();
OnDiskData *&D = M[AU];
if (!D)
D = new OnDiskData();
return *D;
}
static void erasePreambleFile(const ASTUnit *AU) {
getOnDiskData(AU).CleanPreambleFile();
}
static void removeOnDiskEntry(const ASTUnit *AU) {
Add mutex for accessing ASTUnit's global OnDisk data. This may be an issue as libclang could be processing multiple ASTUnit's at once. llvm-svn: 143138
2011-10-28 03:44:25 +08:00
// We require the mutex since we are modifying the structure of the
// DenseMap.
llvm::MutexGuard Guard(getOnDiskMutex());
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
OnDiskDataMap &M = getOnDiskDataMap();
OnDiskDataMap::iterator I = M.find(AU);
if (I != M.end()) {
I->second->Cleanup();
delete I->second;
M.erase(AU);
}
}
static void setPreambleFile(const ASTUnit *AU, llvm::StringRef preambleFile) {
getOnDiskData(AU).PreambleFile = preambleFile;
}
static const std::string &getPreambleFile(const ASTUnit *AU) {
return getOnDiskData(AU).PreambleFile;
}
void OnDiskData::CleanTemporaryFiles() {
for (unsigned I = 0, N = TemporaryFiles.size(); I != N; ++I)
TemporaryFiles[I].eraseFromDisk();
TemporaryFiles.clear();
}
void OnDiskData::CleanPreambleFile() {
if (!PreambleFile.empty()) {
llvm::sys::Path(PreambleFile).eraseFromDisk();
PreambleFile.clear();
}
}
void OnDiskData::Cleanup() {
CleanTemporaryFiles();
CleanPreambleFile();
}
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
void ASTUnit::clearFileLevelDecls() {
for (FileDeclsTy::iterator
I = FileDecls.begin(), E = FileDecls.end(); I != E; ++I)
delete I->second;
FileDecls.clear();
}
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
void ASTUnit::CleanTemporaryFiles() {
getOnDiskData(this).CleanTemporaryFiles();
}
void ASTUnit::addTemporaryFile(const llvm::sys::Path &TempFile) {
getOnDiskData(this).TemporaryFiles.push_back(TempFile);
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
}
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
/// \brief After failing to build a precompiled preamble (due to
/// errors in the source that occurs in the preamble), the number of
/// reparses during which we'll skip even trying to precompile the
/// preamble.
const unsigned DefaultPreambleRebuildInterval = 5;
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
/// \brief Tracks the number of ASTUnit objects that are currently active.
///
/// Used for debugging purposes only.
Use atomic operations for libclang's object count tracking. llvm-svn: 121073
2010-12-07 08:05:48 +08:00
static llvm::sys::cas_flag ActiveASTUnitObjects;
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
ASTUnit::ASTUnit(bool _MainFileIsAST)
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
: Reader(0), OnlyLocalDecls(false), CaptureDiagnostics(false),
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
MainFileIsAST(_MainFileIsAST),
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
TUKind(TU_Complete), WantTiming(getenv("LIBCLANG_TIMING")),
Introduce OwnsRemappedFileBuffers field in ASTUnit, indicating whether the ASTUnit should delete the remapped buffers. llvm-svn: 127051
2011-03-05 09:03:48 +08:00
OwnsRemappedFileBuffers(true),
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
NumStoredDiagnosticsFromDriver(0),
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
PreambleRebuildCounter(0), SavedMainFileBuffer(0), PreambleBuffer(0),
When the # of top-level declarations changes after reparsing a translation unit, refresh code-completion results because they've probably changed. However, enforce a cooldown period between refreshes, to avoid thrashing. llvm-svn: 111218
2010-08-17 08:40:40 +08:00
ShouldCacheCodeCompletionResults(false),
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
NestedMacroExpansions(true),
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
CompletionCacheTopLevelHashValue(0),
PreambleTopLevelHashValue(0),
CurrentTopLevelHashValue(0),
Make sure to initialize ASTUnit::UnsafeToFree llvm-svn: 111490
2010-08-19 08:45:44 +08:00
UnsafeToFree(false) {
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
if (getenv("LIBCLANG_OBJTRACKING")) {
Use atomic operations for libclang's object count tracking. llvm-svn: 121073
2010-12-07 08:05:48 +08:00
llvm::sys::AtomicIncrement(&ActiveASTUnitObjects);
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
fprintf(stderr, "+++ %d translation units\n", ActiveASTUnitObjects);
}
Add some timers to ASTUnit that are only enabled when the LIBCLANG_TIMING environment variable is set. llvm-svn: 109890
2010-07-31 04:58:08 +08:00
}
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
ASTUnit::~ASTUnit() {
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
clearFileLevelDecls();
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
// Clean up the temporary files and the preamble file.
removeOnDiskEntry(this);
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
// Free the buffers associated with remapped files. We are required to
// perform this operation here because we explicitly request that the
// compiler instance *not* free these buffers for each invocation of the
// parser.
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
if (Invocation.getPtr() && OwnsRemappedFileBuffers) {
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
for (PreprocessorOptions::remapped_file_buffer_iterator
FB = PPOpts.remapped_file_buffer_begin(),
FBEnd = PPOpts.remapped_file_buffer_end();
FB != FBEnd;
++FB)
delete FB->second;
}
Fix use-after-free with precompiled preambles llvm-svn: 109505
2010-07-27 22:52:07 +08:00
delete SavedMainFileBuffer;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
delete PreambleBuffer;
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
ClearCachedCompletionResults();
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
if (getenv("LIBCLANG_OBJTRACKING")) {
Use atomic operations for libclang's object count tracking. llvm-svn: 121073
2010-12-07 08:05:48 +08:00
llvm::sys::AtomicDecrement(&ActiveASTUnitObjects);
Fix source-range information for Objective-C properties. Previously, we were just getting a range covering only the property name, which is certainly not correct (and broke token annotation, among other things). Also, teach libclang about the relationship between @synthesize/@dynamic and @property, so we get property name and cursor-reference information for @synthesize and @dynamic. llvm-svn: 119409
2010-11-17 08:13:31 +08:00
fprintf(stderr, "--- %d translation units\n", ActiveASTUnitObjects);
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
}
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
/// \brief Determine the set of code-completion contexts in which this
/// declaration should be shown.
static unsigned getDeclShowContexts(NamedDecl *ND,
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
const LangOptions &LangOpts,
bool &IsNestedNameSpecifier) {
IsNestedNameSpecifier = false;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
if (isa<UsingShadowDecl>(ND))
ND = dyn_cast<NamedDecl>(ND->getUnderlyingDecl());
if (!ND)
return 0;
unsigned Contexts = 0;
if (isa<TypeDecl>(ND) || isa<ObjCInterfaceDecl>(ND) ||
isa<ClassTemplateDecl>(ND) || isa<TemplateTemplateParmDecl>(ND)) {
// Types can appear in these contexts.
if (LangOpts.CPlusPlus || !isa<TagDecl>(ND))
Contexts |= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
| (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
| (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
| (1 << (CodeCompletionContext::CCC_Statement - 1))
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
| (1 << (CodeCompletionContext::CCC_Type - 1))
| (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1));
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
// In C++, types can appear in expressions contexts (for functional casts).
if (LangOpts.CPlusPlus)
Contexts |= (1 << (CodeCompletionContext::CCC_Expression - 1));
// In Objective-C, message sends can send interfaces. In Objective-C++,
// all types are available due to functional casts.
if (LangOpts.CPlusPlus || isa<ObjCInterfaceDecl>(ND))
Contexts |= (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
// In Objective-C, you can only be a subclass of another Objective-C class
if (isa<ObjCInterfaceDecl>(ND))
When performing code completion after at @interface, allow both already-defined and forward-declared results. Already-defined results are fine because they could be the start of a category. Fixes <rdar://problem/9811691>. llvm-svn: 136559
2011-07-30 14:55:39 +08:00
Contexts |= (1 << (CodeCompletionContext::CCC_ObjCInterfaceName - 1));
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
// Deal with tag names.
if (isa<EnumDecl>(ND)) {
Contexts |= (1 << (CodeCompletionContext::CCC_EnumTag - 1));
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
// Part of the nested-name-specifier in C++0x.
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
if (LangOpts.CPlusPlus0x)
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
IsNestedNameSpecifier = true;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
} else if (RecordDecl *Record = dyn_cast<RecordDecl>(ND)) {
if (Record->isUnion())
Contexts |= (1 << (CodeCompletionContext::CCC_UnionTag - 1));
else
Contexts |= (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
if (LangOpts.CPlusPlus)
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
IsNestedNameSpecifier = true;
Synchronize globally-cached code completion results with the results provided when the optimization is disabled. In particular, split the completion context CCC_Other into two contexts: CCC_Other, which means that it's an undisclosed context for which any other results are unwelcome, and CCC_Recovery, which is used in recovery cases. Since we're now using the completion context within the completion results builder, make sure that it's always set to something. Fixes <rdar://problem/8470644>. llvm-svn: 114704
2010-09-24 07:01:17 +08:00
} else if (isa<ClassTemplateDecl>(ND))
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
IsNestedNameSpecifier = true;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
} else if (isa<ValueDecl>(ND) || isa<FunctionTemplateDecl>(ND)) {
// Values can appear in these contexts.
Contexts = (1 << (CodeCompletionContext::CCC_Statement - 1))
| (1 << (CodeCompletionContext::CCC_Expression - 1))
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
| (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
| (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1));
} else if (isa<ObjCProtocolDecl>(ND)) {
Contexts = (1 << (CodeCompletionContext::CCC_ObjCProtocolName - 1));
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
} else if (isa<ObjCCategoryDecl>(ND)) {
Contexts = (1 << (CodeCompletionContext::CCC_ObjCCategoryName - 1));
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
} else if (isa<NamespaceDecl>(ND) || isa<NamespaceAliasDecl>(ND)) {
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
Contexts = (1 << (CodeCompletionContext::CCC_Namespace - 1));
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
// Part of the nested-name-specifier.
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
IsNestedNameSpecifier = true;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
}
return Contexts;
}
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
void ASTUnit::CacheCodeCompletionResults() {
if (!TheSema)
return;
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
SimpleTimer Timer(WantTiming);
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
Timer.setOutput("Cache global code completions for " + getMainFileName());
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
// Clear out the previous results.
ClearCachedCompletionResults();
// Gather the set of global code completions.
Teach Sema to live without CodeCompleteConsumer.h. llvm-svn: 112028
2010-08-25 14:19:51 +08:00
typedef CodeCompletionResult Result;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<Result, 8> Results;
Teach the CXCodeCompleteResults results structure, which stores code-completion results accessed via libclang, to extend the lifetime of the allocator used for cached global code-completion results at least until these completion results are destroyed. Fixes <rdar://problem/8997369>. llvm-svn: 125678
2011-02-17 03:08:06 +08:00
CachedCompletionAllocator = new GlobalCodeCompletionAllocator;
TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, Results);
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
// Translate global code completions into cached completions.
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
llvm::DenseMap<CanQualType, unsigned> CompletionTypes;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
for (unsigned I = 0, N = Results.size(); I != N; ++I) {
switch (Results[I].Kind) {
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
case Result::RK_Declaration: {
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
bool IsNestedNameSpecifier = false;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
CachedCodeCompletionResult CachedResult;
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
CachedResult.Completion = Results[I].CreateCodeCompletionString(*TheSema,
Teach the CXCodeCompleteResults results structure, which stores code-completion results accessed via libclang, to extend the lifetime of the allocator used for cached global code-completion results at least until these completion results are destroyed. Fixes <rdar://problem/8997369>. llvm-svn: 125678
2011-02-17 03:08:06 +08:00
*CachedCompletionAllocator);
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
CachedResult.ShowInContexts = getDeclShowContexts(Results[I].Declaration,
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
Ctx->getLangOptions(),
IsNestedNameSpecifier);
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
CachedResult.Priority = Results[I].Priority;
CachedResult.Kind = Results[I].CursorKind;
Introduce new libclang API functions that determine the availability of a cursor or code-completion result, e.g., whether that result refers to an unavailable, deleted, or deprecated declaration. llvm-svn: 111858
2010-08-24 07:00:57 +08:00
CachedResult.Availability = Results[I].Availability;
Dereferencing NULL pointers is such poor form. llvm-svn: 111150
2010-08-17 00:46:30 +08:00
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
// Keep track of the type of this completion in an ASTContext-agnostic
// way.
Dereferencing NULL pointers is such poor form. llvm-svn: 111150
2010-08-17 00:46:30 +08:00
QualType UsageType = getDeclUsageType(*Ctx, Results[I].Declaration);
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
if (UsageType.isNull()) {
Dereferencing NULL pointers is such poor form. llvm-svn: 111150
2010-08-17 00:46:30 +08:00
CachedResult.TypeClass = STC_Void;
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
CachedResult.Type = 0;
} else {
CanQualType CanUsageType
= Ctx->getCanonicalType(UsageType.getUnqualifiedType());
CachedResult.TypeClass = getSimplifiedTypeClass(CanUsageType);
// Determine whether we have already seen this type. If so, we save
// ourselves the work of formatting the type string by using the
// temporary, CanQualType-based hash table to find the associated value.
unsigned &TypeValue = CompletionTypes[CanUsageType];
if (TypeValue == 0) {
TypeValue = CompletionTypes.size();
CachedCompletionTypes[QualType(CanUsageType).getAsString()]
= TypeValue;
}
CachedResult.Type = TypeValue;
Dereferencing NULL pointers is such poor form. llvm-svn: 111150
2010-08-17 00:46:30 +08:00
}
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
CachedCompletionResults.push_back(CachedResult);
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
/// Handle nested-name-specifiers in C++.
if (TheSema->Context.getLangOptions().CPlusPlus &&
IsNestedNameSpecifier && !Results[I].StartsNestedNameSpecifier) {
// The contexts in which a nested-name-specifier can appear in C++.
unsigned NNSContexts
= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
| (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
| (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
| (1 << (CodeCompletionContext::CCC_Statement - 1))
| (1 << (CodeCompletionContext::CCC_Expression - 1))
| (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
| (1 << (CodeCompletionContext::CCC_EnumTag - 1))
| (1 << (CodeCompletionContext::CCC_UnionTag - 1))
| (1 << (CodeCompletionContext::CCC_ClassOrStructTag - 1))
Introduce a new code-completion point when we're parsing a declarator. Here, we can only see a few things (e.g., cvr-qualifiers, nested name specifiers) and we do not want to provide other non-macro completions. Previously, we would end up in recovery mode and would provide a large number of non-relevant completions. llvm-svn: 111818
2010-08-24 02:23:48 +08:00
| (1 << (CodeCompletionContext::CCC_Type - 1))
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
| (1 << (CodeCompletionContext::CCC_PotentiallyQualifiedName - 1))
| (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1));
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
if (isa<NamespaceDecl>(Results[I].Declaration) ||
isa<NamespaceAliasDecl>(Results[I].Declaration))
NNSContexts |= (1 << (CodeCompletionContext::CCC_Namespace - 1));
if (unsigned RemainingContexts
= NNSContexts & ~CachedResult.ShowInContexts) {
// If there any contexts where this completion can be a
// nested-name-specifier but isn't already an option, create a
// nested-name-specifier completion.
Results[I].StartsNestedNameSpecifier = true;
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
CachedResult.Completion
= Results[I].CreateCodeCompletionString(*TheSema,
Teach the CXCodeCompleteResults results structure, which stores code-completion results accessed via libclang, to extend the lifetime of the allocator used for cached global code-completion results at least until these completion results are destroyed. Fixes <rdar://problem/8997369>. llvm-svn: 125678
2011-02-17 03:08:06 +08:00
*CachedCompletionAllocator);
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
CachedResult.ShowInContexts = RemainingContexts;
CachedResult.Priority = CCP_NestedNameSpecifier;
CachedResult.TypeClass = STC_Void;
CachedResult.Type = 0;
CachedCompletionResults.push_back(CachedResult);
}
}
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
break;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
}
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
case Result::RK_Keyword:
case Result::RK_Pattern:
// Ignore keywords and patterns; we don't care, since they are so
// easily regenerated.
break;
case Result::RK_Macro: {
CachedCodeCompletionResult CachedResult;
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
CachedResult.Completion
= Results[I].CreateCodeCompletionString(*TheSema,
Teach the CXCodeCompleteResults results structure, which stores code-completion results accessed via libclang, to extend the lifetime of the allocator used for cached global code-completion results at least until these completion results are destroyed. Fixes <rdar://problem/8997369>. llvm-svn: 125678
2011-02-17 03:08:06 +08:00
*CachedCompletionAllocator);
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
CachedResult.ShowInContexts
= (1 << (CodeCompletionContext::CCC_TopLevel - 1))
| (1 << (CodeCompletionContext::CCC_ObjCInterface - 1))
| (1 << (CodeCompletionContext::CCC_ObjCImplementation - 1))
| (1 << (CodeCompletionContext::CCC_ObjCIvarList - 1))
| (1 << (CodeCompletionContext::CCC_ClassStructUnion - 1))
| (1 << (CodeCompletionContext::CCC_Statement - 1))
| (1 << (CodeCompletionContext::CCC_Expression - 1))
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
| (1 << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
Implement code completion for preprocessor expressions and in macro arguments. llvm-svn: 111976
2010-08-25 06:20:20 +08:00
| (1 << (CodeCompletionContext::CCC_MacroNameUse - 1))
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
| (1 << (CodeCompletionContext::CCC_PreprocessorExpression - 1))
When code-completing a case statement for a switch on a value of enumeration type, prioritize the enumeration constants and don't provide completions for any other expressions. Fixes <rdar://problem/7283668>. llvm-svn: 125991
2011-02-19 07:30:37 +08:00
| (1 << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
| (1 << (CodeCompletionContext::CCC_OtherWithMacros - 1));
Introduce a new code-completion point when we're parsing a declarator. Here, we can only see a few things (e.g., cvr-qualifiers, nested name specifiers) and we do not want to provide other non-macro completions. Previously, we would end up in recovery mode and would provide a large number of non-relevant completions. llvm-svn: 111818
2010-08-24 02:23:48 +08:00
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
CachedResult.Priority = Results[I].Priority;
CachedResult.Kind = Results[I].CursorKind;
Introduce new libclang API functions that determine the availability of a cursor or code-completion result, e.g., whether that result refers to an unavailable, deleted, or deprecated declaration. llvm-svn: 111858
2010-08-24 07:00:57 +08:00
CachedResult.Availability = Results[I].Availability;
When caching global completion results, keep track of the simplified type class, so that we can adjust priorities appropriately when the preferred type for the context and the actual type of the completion are similar. This gets us one step closer to parity of the cached completion results with the non-cached completion results. llvm-svn: 111139
2010-08-17 00:18:59 +08:00
CachedResult.TypeClass = STC_Void;
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
CachedResult.Type = 0;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
CachedCompletionResults.push_back(CachedResult);
break;
}
}
}
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
// Save the current top-level hash value.
CompletionCacheTopLevelHashValue = CurrentTopLevelHashValue;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
}
void ASTUnit::ClearCachedCompletionResults() {
CachedCompletionResults.clear();
When caching code completions for global declarations, keep track of the usage type of each declaration result, then compare those types to the preferred type of the completion. This provides parity in the priority calculation between the code-completion results produced directly from Sema and those cached by ASTUnit. For the standard Cocoa.h (+ others) example, there's a penalty of 3-4 hundredeths of a second when caching the global results (for ~31,000 results), because we need an ASTContext-agnostic representation of types for the comparison, and therefore we use... strings. Eventually, we'd like to implement a more efficient ASTContext-agnostic encoding of types. llvm-svn: 111165
2010-08-17 02:08:11 +08:00
CachedCompletionTypes.clear();
Teach the CXCodeCompleteResults results structure, which stores code-completion results accessed via libclang, to extend the lifetime of the allocator used for cached global code-completion results at least until these completion results are destroyed. Fixes <rdar://problem/8997369>. llvm-svn: 125678
2011-02-17 03:08:06 +08:00
CachedCompletionAllocator = 0;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
}
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
namespace {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
/// \brief Gathers information from ASTReader that will be used to initialize
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
/// a Preprocessor.
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
class ASTInfoCollector : public ASTReaderListener {
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
Preprocessor &PP;
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
ASTContext &Context;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
LangOptions &LangOpt;
HeaderSearch &HSI;
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
llvm::IntrusiveRefCntPtr<TargetInfo> &Target;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
std::string &Predefines;
unsigned &Counter;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
unsigned NumHeaderInfos;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
bool InitializedLanguage;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
public:
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
ASTInfoCollector(Preprocessor &PP, ASTContext &Context, LangOptions &LangOpt,
HeaderSearch &HSI,
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
llvm::IntrusiveRefCntPtr<TargetInfo> &Target,
std::string &Predefines,
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
unsigned &Counter)
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
: PP(PP), Context(Context), LangOpt(LangOpt), HSI(HSI), Target(Target),
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
Predefines(Predefines), Counter(Counter), NumHeaderInfos(0),
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
InitializedLanguage(false) {}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
virtual bool ReadLanguageOptions(const LangOptions &LangOpts) {
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
if (InitializedLanguage)
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
return false;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
LangOpt = LangOpts;
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
// Initialize the preprocessor.
PP.Initialize(*Target);
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
// Initialize the ASTContext
Context.InitBuiltinTypes(*Target);
InitializedLanguage = true;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
return false;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
virtual bool ReadTargetTriple(StringRef Triple) {
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
// If we've already initialized the target, don't do it again.
if (Target)
return false;
// FIXME: This is broken, we should store the TargetOptions in the AST file.
TargetOptions TargetOpts;
TargetOpts.ABI = "";
TargetOpts.CXXABI = "";
TargetOpts.CPU = "";
TargetOpts.Features.clear();
TargetOpts.Triple = Triple;
Target = TargetInfo::CreateTargetInfo(PP.getDiagnostics(), TargetOpts);
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
return false;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
There is another implementation of PCHReaderListener around. Update it to the new interface. llvm-svn: 108377
2010-07-15 07:29:55 +08:00
virtual bool ReadPredefinesBuffer(const PCHPredefinesBlocks &Buffers,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef OriginalFileName,
Preserve what the user passed to -include when emitting .d files. Fixes PR8974! llvm-svn: 126334
2011-02-24 05:16:44 +08:00
std::string &SuggestedPredefines,
FileManager &FileMgr) {
There is another implementation of PCHReaderListener around. Update it to the new interface. llvm-svn: 108377
2010-07-15 07:29:55 +08:00
Predefines = Buffers[0].Data;
for (unsigned I = 1, N = Buffers.size(); I != N; ++I) {
Predefines += Buffers[I].Data;
}
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
return false;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Make sure we actually override ReadHeaderFileInfo when we meant to llvm-svn: 98655
2010-03-17 03:09:18 +08:00
virtual void ReadHeaderFileInfo(const HeaderFileInfo &HFI, unsigned ID) {
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
HSI.setHeaderFileInfoForUID(HFI, NumHeaderInfos++);
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
virtual void ReadCounter(unsigned Value) {
Counter = Value;
}
};
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
class StoredDiagnosticConsumer : public DiagnosticConsumer {
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<StoredDiagnostic> &StoredDiags;
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
public:
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
explicit StoredDiagnosticConsumer(
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<StoredDiagnostic> &StoredDiags)
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
: StoredDiags(StoredDiags) { }
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
virtual void HandleDiagnostic(DiagnosticsEngine::Level Level,
Rename DiagnosticInfo to Diagnostic as per issue 5397 llvm-svn: 140493
2011-09-26 09:18:08 +08:00
const Diagnostic &Info);
Introduce a pure virtual clone() method to DiagnosticConsumer, so that we have the ability to create a new, distict diagnostic consumer when we go off and build a module. This avoids the currently horribleness where the same diagnostic consumer sees diagnostics for multiple translation units (and multiple SourceManagers!) causing all sorts of havok. llvm-svn: 140743
2011-09-29 08:38:00 +08:00
DiagnosticConsumer *clone(DiagnosticsEngine &Diags) const {
// Just drop any diagnostics that come from cloned consumers; they'll
// have different source managers anyway.
return new IgnoringDiagConsumer();
}
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
};
/// \brief RAII object that optionally captures diagnostics, if
/// there is no diagnostic client to capture them already.
class CaptureDroppedDiagnostics {
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diags;
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
StoredDiagnosticConsumer Client;
Rename DiagnosticClient to DiagnosticConsumer as per issue 5397 llvm-svn: 140479
2011-09-26 07:39:51 +08:00
DiagnosticConsumer *PreviousClient;
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
public:
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
CaptureDroppedDiagnostics(bool RequestCapture, DiagnosticsEngine &Diags,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<StoredDiagnostic> &StoredDiags)
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
: Diags(Diags), Client(StoredDiags), PreviousClient(0)
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
{
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
if (RequestCapture || Diags.getClient() == 0) {
PreviousClient = Diags.takeClient();
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
Diags.setClient(&Client);
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
}
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
}
~CaptureDroppedDiagnostics() {
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
if (Diags.getClient() == &Client) {
Diags.takeClient();
Diags.setClient(PreviousClient);
}
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
}
};
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
} // anonymous namespace
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
void StoredDiagnosticConsumer::HandleDiagnostic(DiagnosticsEngine::Level Level,
Rename DiagnosticInfo to Diagnostic as per issue 5397 llvm-svn: 140493
2011-09-26 09:18:08 +08:00
const Diagnostic &Info) {
Since multiple diagnostics can share one diagnostic client, have the client keeping track of the total number of warnings/errors reported. llvm-svn: 119731
2010-11-19 04:06:46 +08:00
// Default implementation (Warnings/errors count).
Rename DiagnosticClient to DiagnosticConsumer as per issue 5397 llvm-svn: 140479
2011-09-26 07:39:51 +08:00
DiagnosticConsumer::HandleDiagnostic(Level, Info);
Since multiple diagnostics can share one diagnostic client, have the client keeping track of the total number of warnings/errors reported. llvm-svn: 119731
2010-11-19 04:06:46 +08:00
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
StoredDiags.push_back(StoredDiagnostic(Level, Info));
}
Add ASTUnit::getOriginalSourceFileName() and use in clang_getTranslationUnitSpelling(). llvm-svn: 80932
2009-09-04 02:19:54 +08:00
const std::string &ASTUnit::getOriginalSourceFileName() {
Fix ASTUnit::getOriginalSourceFileName() when using ASTUnit's derived from source files. llvm-svn: 90311
2009-12-02 16:44:16 +08:00
return OriginalSourceFile;
Add ASTUnit::getOriginalSourceFileName() and use in clang_getTranslationUnitSpelling(). llvm-svn: 80932
2009-09-04 02:19:54 +08:00
}
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
llvm::MemoryBuffer *ASTUnit::getBufferForFile(StringRef Filename,
tidy up. Split FileManager::getBufferForFile into two copies, since they are fundamentally different operations and the StringRef one should go away (it shouldn't be part of FileManager at least). Remove some dead arguments. llvm-svn: 120013
2010-11-23 17:19:42 +08:00
std::string *ErrorStr) {
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
assert(FileMgr);
tidy up. Split FileManager::getBufferForFile into two copies, since they are fundamentally different operations and the StringRef one should go away (it shouldn't be part of FileManager at least). Remove some dead arguments. llvm-svn: 120013
2010-11-23 17:19:42 +08:00
return FileMgr->getBufferForFile(Filename, ErrorStr);
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
}
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
/// \brief Configure the diagnostics object for use with ASTUnit.
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
void ASTUnit::ConfigureDiags(llvm::IntrusiveRefCntPtr<DiagnosticsEngine> &Diags,
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
const char **ArgBegin, const char **ArgEnd,
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
ASTUnit &AST, bool CaptureDiagnostics) {
if (!Diags.getPtr()) {
// No diagnostics engine was provided, so create our own diagnostics object
// with the default options.
DiagnosticOptions DiagOpts;
Rename DiagnosticClient to DiagnosticConsumer as per issue 5397 llvm-svn: 140479
2011-09-26 07:39:51 +08:00
DiagnosticConsumer *Client = 0;
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
if (CaptureDiagnostics)
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
Client = new StoredDiagnosticConsumer(AST.StoredDiagnostics);
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd- ArgBegin,
ArgBegin, Client);
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
} else if (CaptureDiagnostics) {
Rename StoredDiagnosticClient to StoredDiagnosticConsumer as per issue 5397 llvm-svn: 140483
2011-09-26 08:01:39 +08:00
Diags->setClient(new StoredDiagnosticConsumer(AST.StoredDiagnostics));
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
}
}
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
ASTUnit *ASTUnit::LoadFromASTFile(const std::string &Filename,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
const FileSystemOptions &FileSystemOpts,
Add 'UseBumpPtrAllocator' flag to ASTUnit::LoadFromPCHFile() to cause the created ASTContext to use its own BumpPtrAllocator to allocate ASTs. Change clang_createTranslationUnit (CIndex) to pass 'UseBumpPtrAllocator = true' to ASTUnit::LoadFromPCHFile(). llvm-svn: 84296
2009-10-17 08:34:24 +08:00
bool OnlyLocalDecls,
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
RemappedFile *RemappedFiles,
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
unsigned NumRemappedFiles,
bool CaptureDiagnostics) {
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
llvm::OwningPtr<ASTUnit> AST(new ASTUnit(true));
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
ASTUnitCleanup(AST.get());
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
DiagCleanup(Diags.getPtr());
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics);
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Keep track of whether declararions were loaded from a precompiled header or not via a new "PCHLevel" field in Decl. We currently use this information to help CIndex filter out declarations that came from a precompiled header (rather than from an AST file). Further down the road, it can be used to help implement multi-level precompiled headers. llvm-svn: 84267
2009-10-17 04:01:17 +08:00
AST->OnlyLocalDecls = OnlyLocalDecls;
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
AST->CaptureDiagnostics = CaptureDiagnostics;
Make Diagnostic reference-counted, which is simpler than juggling maybe-ownership vs. ownership. llvm-svn: 100498
2010-04-06 07:52:57 +08:00
AST->Diagnostics = Diags;
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->FileMgr = new FileManager(FileSystemOpts);
AST->SourceMgr = new SourceManager(AST->getDiagnostics(),
AST->getFileManager());
I predict that HeaderSearch will need the ability to generate diagnostics in the future. Make it so. llvm-svn: 144347
2011-11-11 08:35:06 +08:00
AST->HeaderInfo.reset(new HeaderSearch(AST->getFileManager(),
AST->getDiagnostics()));
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
for (unsigned I = 0; I != NumRemappedFiles; ++I) {
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
if (const llvm::MemoryBuffer *
memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
// Create the file entry for the file that we're mapping from.
const FileEntry *FromFile
= AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
memBuf->getBufferSize(),
0);
if (!FromFile) {
AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
<< RemappedFiles[I].first;
delete memBuf;
continue;
}
// Override the contents of the "from" file with the contents of
// the "to" file.
AST->getSourceManager().overrideFileContents(FromFile, memBuf);
} else {
const char *fname = fileOrBuf.get<const char *>();
const FileEntry *ToFile = AST->FileMgr->getFile(fname);
if (!ToFile) {
AST->getDiagnostics().Report(diag::err_fe_remap_missing_to_file)
<< RemappedFiles[I].first << fname;
continue;
}
// Create the file entry for the file that we're mapping from.
const FileEntry *FromFile
= AST->getFileManager().getVirtualFile(RemappedFiles[I].first,
ToFile->getSize(),
0);
if (!FromFile) {
AST->getDiagnostics().Report(diag::err_fe_remap_missing_from_file)
<< RemappedFiles[I].first;
delete memBuf;
continue;
}
// Override the contents of the "from" file with the contents of
// the "to" file.
AST->getSourceManager().overrideFileContents(FromFile, ToFile);
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
}
}
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
// Gather Info for preprocessor construction later on.
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
HeaderSearch &HeaderInfo = *AST->HeaderInfo.get();
std::string Predefines;
unsigned Counter;
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
llvm::OwningPtr<ASTReader> Reader;
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
AST->PP = new Preprocessor(AST->getDiagnostics(), AST->ASTFileLangOpts,
/*Target=*/0, AST->getSourceManager(), HeaderInfo,
*AST,
/*IILookup=*/0,
/*OwnsHeaderSearch=*/false,
/*DelayInitialization=*/true);
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
Preprocessor &PP = *AST->PP;
AST->Ctx = new ASTContext(AST->ASTFileLangOpts,
AST->getSourceManager(),
/*Target=*/0,
PP.getIdentifierTable(),
PP.getSelectorTable(),
PP.getBuiltinInfo(),
/* size_reserve = */0,
/*DelayInitialization=*/true);
ASTContext &Context = *AST->Ctx;
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
Always construct an ASTReader with a non-NULL ASTContext and Preprocessor, eliminating the constructor that was used by ASTUnit (which didn't provide an ASTContext or Prepreprocessor). Ensuring that both objects are non-NULL will simplify module loading (but none of that is done yet). llvm-svn: 138986
2011-09-02 08:26:20 +08:00
Reader.reset(new ASTReader(PP, Context));
ASTUnit::LoadFromASTFile(): recover the resources from an ASTReader if it crashes during PCH validation. llvm-svn: 130886
2011-05-05 07:27:12 +08:00
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<ASTReader>
ReaderCleanup(Reader.get());
Extend the ASTContext constructor to delay the initialization of builtin types (When requested). This is another step toward making ASTUnit build the ASTContext as needed when loading an AST file, rather than doing so after the fact. No actual functionality change (yet). llvm-svn: 138985
2011-09-02 08:18:52 +08:00
Reader->setListener(new ASTInfoCollector(*AST->PP, Context,
Allow the preprocessor to be constructed without performing target- and language-specific initialization. Use this to allow ASTUnit to create a preprocessor object *before* loading the AST file. No actual functionality change. llvm-svn: 138983
2011-09-02 07:39:15 +08:00
AST->ASTFileLangOpts, HeaderInfo,
AST->Target, Predefines, Counter));
Revert "Remove redundant local variable (use newly created instance data).", the previous commit this depends on is breaking x86_64-apple-darwin10 and Linux tests. llvm-svn: 80895
2009-09-03 13:59:35 +08:00
Rename ASTReader::PerFileData to serialization::Module, pulling it out of ASTReader so it can become its own full-fledged class (eventually). No functionality change. llvm-svn: 135767
2011-07-23 00:00:58 +08:00
switch (Reader->ReadAST(Filename, serialization::MK_MainFile)) {
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
case ASTReader::Success:
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
break;
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
case ASTReader::Failure:
case ASTReader::IgnorePCH:
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
AST->getDiagnostics().Report(diag::err_fe_unable_to_load_pch);
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
return NULL;
}
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Fix ASTUnit::getOriginalSourceFileName() when using ASTUnit's derived from source files. llvm-svn: 90311
2009-12-02 16:44:16 +08:00
AST->OriginalSourceFile = Reader->getOriginalSourceFile();
Change ASTUnit to only initialize the predefines buffer to the suggested predefines. - It isn't really clear what to do with the preprocessor here, but this is more sensible. llvm-svn: 82431
2009-09-21 11:03:47 +08:00
PP.setPredefines(Reader->getSuggestedPredefines());
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
PP.setCounterValue(Counter);
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// Attach the AST reader to the AST context as an external AST
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
// source, so that declarations will be deserialized from the
More PCH -> AST renaming. llvm-svn: 111472
2010-08-19 07:57:06 +08:00
// AST file as needed.
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
ASTReader *ReaderPtr = Reader.get();
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
llvm::OwningPtr<ExternalASTSource> Source(Reader.take());
ASTUnit::LoadFromASTFile(): recover the resources from an ASTReader if it crashes during PCH validation. llvm-svn: 130886
2011-05-05 07:27:12 +08:00
// Unregister the cleanup for ASTReader. It will get cleaned up
// by the ASTUnit cleanup.
ReaderCleanup.unregister();
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
Context.setExternalSource(Source);
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
// Create an AST consumer, even though it isn't used.
AST->Consumer.reset(new ASTConsumer);
Rename PCHReader to ASTReader. llvm-svn: 111467
2010-08-19 07:56:43 +08:00
// Create a semantic analysis object and tell the AST reader about it.
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
AST->TheSema.reset(new Sema(PP, Context, *AST->Consumer));
AST->TheSema->Initialize();
ReaderPtr->InitializeSema(*AST->TheSema);
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
AST->Reader = ReaderPtr;
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
Remove tabs, and whitespace cleanups. llvm-svn: 81346
2009-09-09 23:08:12 +08:00
return AST.take();
Introduce the ASTUnit class. ASTUnit is a helper class to allow easy loading of an ASTContext from a PCH file. No users for now. llvm-svn: 73819
2009-06-20 16:08:23 +08:00
}
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
namespace {
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
/// \brief Preprocessor callback class that updates a hash value with the names
/// of all macros that have been defined by the translation unit.
class MacroDefinitionTrackerPPCallbacks : public PPCallbacks {
unsigned &Hash;
public:
explicit MacroDefinitionTrackerPPCallbacks(unsigned &Hash) : Hash(Hash) { }
virtual void MacroDefined(const Token &MacroNameTok, const MacroInfo *MI) {
Hash = llvm::HashString(MacroNameTok.getIdentifierInfo()->getName(), Hash);
}
};
/// \brief Add the given declaration to the hash of all top-level entities.
void AddTopLevelDeclarationToHash(Decl *D, unsigned &Hash) {
if (!D)
return;
DeclContext *DC = D->getDeclContext();
if (!DC)
return;
if (!(DC->isTranslationUnit() || DC->getLookupParent()->isTranslationUnit()))
return;
if (NamedDecl *ND = dyn_cast<NamedDecl>(D)) {
if (ND->getIdentifier())
Hash = llvm::HashString(ND->getIdentifier()->getName(), Hash);
else if (DeclarationName Name = ND->getDeclName()) {
std::string NameStr = Name.getAsString();
Hash = llvm::HashString(NameStr, Hash);
}
return;
}
if (ObjCForwardProtocolDecl *Forward
= dyn_cast<ObjCForwardProtocolDecl>(D)) {
for (ObjCForwardProtocolDecl::protocol_iterator
P = Forward->protocol_begin(),
PEnd = Forward->protocol_end();
P != PEnd; ++P)
AddTopLevelDeclarationToHash(*P, Hash);
return;
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
if (ObjCClassDecl *Class = dyn_cast<ObjCClassDecl>(D)) {
objective-c: Treat top-level objective-c declarations , such as list of forward @class decls, in a DeclGroup node. Deal with its consequence throught clang. This is in preparation for more Sema work ahead. // rdar://8843851. Feel free to reverse if it breaks something important and I am unavailable. llvm-svn: 138709
2011-08-28 04:50:59 +08:00
AddTopLevelDeclarationToHash(Class->getForwardInterfaceDecl(), Hash);
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
return;
}
}
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
class TopLevelDeclTrackerConsumer : public ASTConsumer {
ASTUnit &Unit;
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
unsigned &Hash;
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
public:
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
TopLevelDeclTrackerConsumer(ASTUnit &_Unit, unsigned &Hash)
: Unit(_Unit), Hash(Hash) {
Hash = 0;
}
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
void handleTopLevelDecl(Decl *D) {
[libclang] Fix crash on invalid code. Fixes rdar://10451854 llvm-svn: 144766
2011-11-16 10:35:10 +08:00
if (!D)
return;
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
// FIXME: Currently ObjC method declarations are incorrectly being
// reported as top-level declarations, even though their DeclContext
// is the containing ObjC @interface/@implementation. This is a
// fundamental problem in the parser right now.
if (isa<ObjCMethodDecl>(D))
return;
AddTopLevelDeclarationToHash(D, Hash);
Unit.addTopLevelDecl(D);
handleFileLevelDecl(D);
}
void handleFileLevelDecl(Decl *D) {
Unit.addFileLevelDecl(D);
if (NamespaceDecl *NSD = dyn_cast<NamespaceDecl>(D)) {
for (NamespaceDecl::decl_iterator
I = NSD->decls_begin(), E = NSD->decls_end(); I != E; ++I)
handleFileLevelDecl(*I);
Workaround: Don't add ObjCMethodDecls to the vector of TopLevelDecls since they don't go in the DeclContext for the translation unit. This is to workaround a fundamental issue in how ObjC decls (within an @implementation) are parsed before the ObjCContainerDecl is available. llvm-svn: 102944
2010-05-04 04:16:35 +08:00
}
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
}
Reintroduce the ASTConsumer/ASTUnit fix from r110610, it has nothing to do with the breakage. llvm-svn: 110840
2010-08-12 02:52:41 +08:00
Change ASTConsumer::HandleTopLevelDecl to return true for the parser to continue parsing or false to abort parsing. llvm-svn: 144943
2011-11-18 08:26:59 +08:00
bool HandleTopLevelDecl(DeclGroupRef D) {
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it)
handleTopLevelDecl(*it);
Change ASTConsumer::HandleTopLevelDecl to return true for the parser to continue parsing or false to abort parsing. llvm-svn: 144943
2011-11-18 08:26:59 +08:00
return true;
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
}
Reintroduce the ASTConsumer/ASTUnit fix from r110610, it has nothing to do with the breakage. llvm-svn: 110840
2010-08-12 02:52:41 +08:00
// We're not interested in "interesting" decls.
void HandleInterestingDecl(DeclGroupRef) {}
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
void HandleTopLevelDeclInObjCContainer(DeclGroupRef D) {
for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it)
handleTopLevelDecl(*it);
}
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
};
class TopLevelDeclTrackerAction : public ASTFrontendAction {
public:
ASTUnit &Unit;
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef InFile) {
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
CI.getPreprocessor().addPPCallbacks(
new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue()));
return new TopLevelDeclTrackerConsumer(Unit,
Unit.getCurrentTopLevelHashValue());
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
}
public:
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
TopLevelDeclTrackerAction(ASTUnit &_Unit) : Unit(_Unit) {}
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
virtual bool hasCodeCompletionSupport() const { return false; }
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
virtual TranslationUnitKind getTranslationUnitKind() {
return Unit.getTranslationUnitKind();
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
}
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
};
In libclang, when visiting preprocessed entities in a source range, use PreprocessingRecord's getPreprocessedEntitiesInRange. Also remove all the stuff that were added in ASTUnit that are unnecessary now that we do a binary search for preprocessed entities and deserialize only what is necessary. llvm-svn: 140063
2011-09-20 04:40:48 +08:00
class PrecompilePreambleConsumer : public PCHGenerator {
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
ASTUnit &Unit;
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
unsigned &Hash;
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
std::vector<Decl *> TopLevelDecls;
When using a precompiled preamble with detailed preprocessing records, trap the serialized preprocessing records (macro definitions, macro instantiations, macro definitions) from the generation of the precompiled preamble, then replay those when walking the list of preprocessed entities. This eliminates a bug where clang_getCursor() wasn't able to find preprocessed-entity cursors in the preamble. llvm-svn: 120396
2010-11-30 14:16:57 +08:00
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
public:
Remove the Chaining argument from the PCH/module generator. It's no longer used llvm-svn: 138596
2011-08-26 06:35:51 +08:00
PrecompilePreambleConsumer(ASTUnit &Unit, const Preprocessor &PP,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef isysroot, raw_ostream *Out)
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
: PCHGenerator(PP, "", /*IsModule=*/false, isysroot, Out), Unit(Unit),
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
Hash(Unit.getCurrentTopLevelHashValue()) {
Hash = 0;
}
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
Change ASTConsumer::HandleTopLevelDecl to return true for the parser to continue parsing or false to abort parsing. llvm-svn: 144943
2011-11-18 08:26:59 +08:00
virtual bool HandleTopLevelDecl(DeclGroupRef D) {
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
for (DeclGroupRef::iterator it = D.begin(), ie = D.end(); it != ie; ++it) {
Decl *D = *it;
// FIXME: Currently ObjC method declarations are incorrectly being
// reported as top-level declarations, even though their DeclContext
// is the containing ObjC @interface/@implementation. This is a
// fundamental problem in the parser right now.
if (isa<ObjCMethodDecl>(D))
continue;
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
AddTopLevelDeclarationToHash(D, Hash);
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
TopLevelDecls.push_back(D);
}
Change ASTConsumer::HandleTopLevelDecl to return true for the parser to continue parsing or false to abort parsing. llvm-svn: 144943
2011-11-18 08:26:59 +08:00
return true;
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
}
virtual void HandleTranslationUnit(ASTContext &Ctx) {
PCHGenerator::HandleTranslationUnit(Ctx);
if (!Unit.getDiagnostics().hasErrorOccurred()) {
// Translate the top-level declarations we captured during
// parsing into declaration IDs in the precompiled
// preamble. This will allow us to deserialize those top-level
// declarations when requested.
for (unsigned I = 0, N = TopLevelDecls.size(); I != N; ++I)
Unit.addTopLevelDeclFromPreamble(
getWriter().getDeclID(TopLevelDecls[I]));
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
}
}
};
class PrecompilePreambleAction : public ASTFrontendAction {
ASTUnit &Unit;
public:
explicit PrecompilePreambleAction(ASTUnit &Unit) : Unit(Unit) {}
virtual ASTConsumer *CreateASTConsumer(CompilerInstance &CI,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef InFile) {
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
std::string Sysroot;
Allow resolving headers from a PCH even after headers+PCH were moved to another path. Store in PCH the directory that the PCH was originally created in. If a header file is not found at the path that we expect it to be and the PCH file was moved from its original location, try to resolve the file by assuming that header+PCH were moved together and the header is in the same place relative to the PCH. llvm-svn: 125576
2011-02-16 01:54:22 +08:00
std::string OutputFile;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
raw_ostream *OS = 0;
Allow resolving headers from a PCH even after headers+PCH were moved to another path. Store in PCH the directory that the PCH was originally created in. If a header file is not found at the path that we expect it to be and the PCH file was moved from its original location, try to resolve the file by assuming that header+PCH were moved together and the header is in the same place relative to the PCH. llvm-svn: 125576
2011-02-16 01:54:22 +08:00
if (GeneratePCHAction::ComputeASTConsumerArguments(CI, InFile, Sysroot,
OutputFile,
Remove the Chaining argument from the PCH/module generator. It's no longer used llvm-svn: 138596
2011-08-26 06:35:51 +08:00
OS))
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
return 0;
Switch all of the "isysroot" const char*'s throughout the AST reader and writer to StringRef or std::string, as appropriate. llvm-svn: 135769
2011-07-23 00:35:34 +08:00
if (!CI.getFrontendOpts().RelocatablePCH)
Sysroot.clear();
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
CI.getPreprocessor().addPPCallbacks(
new MacroDefinitionTrackerPPCallbacks(Unit.getCurrentTopLevelHashValue()));
Remove the Chaining argument from the PCH/module generator. It's no longer used llvm-svn: 138596
2011-08-26 06:35:51 +08:00
return new PrecompilePreambleConsumer(Unit, CI.getPreprocessor(), Sysroot,
OS);
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
}
virtual bool hasCodeCompletionSupport() const { return false; }
virtual bool hasASTFileSupport() const { return false; }
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
virtual TranslationUnitKind getTranslationUnitKind() { return TU_Prefix; }
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
};
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
/// Parse the source file into a translation unit using the given compiler
/// invocation, replacing the current translation unit.
///
/// \returns True if a failure occurred that causes the ASTUnit not to
/// contain any translation-unit information, false otherwise.
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
bool ASTUnit::Parse(llvm::MemoryBuffer *OverrideMainBuffer) {
Fix use-after-free with precompiled preambles llvm-svn: 109505
2010-07-27 22:52:07 +08:00
delete SavedMainFileBuffer;
SavedMainFileBuffer = 0;
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
if (!Invocation) {
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
delete OverrideMainBuffer;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
return true;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
// Create the compiler instance to use for building the AST.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get());
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
[libclang] In ASTUnit::Parse copy the CompilerInvocation object instead of modifying directly for the preamble. This avoids an awful, hard to find, bug where "PreprocessorOpts.DisablePCHValidation = true" would be persistent for subsequent reparses of the translation unit which would result in defines, present in command-line but not in the PCH, being ignored. Fixes rdar://9615399. llvm-svn: 139512
2011-09-13 02:09:38 +08:00
llvm::IntrusiveRefCntPtr<CompilerInvocation>
CCInvocation(new CompilerInvocation(*Invocation));
Clang->setInvocation(CCInvocation.getPtr());
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
// Set up diagnostics, capturing any diagnostics that would
// otherwise be dropped.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setDiagnostics(&getDiagnostics());
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
// Create the target instance.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTargetOpts().Features = TargetFeatures;
Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Clang->getTargetOpts()));
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
if (!Clang->hasTarget()) {
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
delete OverrideMainBuffer;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
return true;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
}
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
// Inform the target of the language options.
//
// FIXME: We shouldn't need to do this, the target should be immutable once
// created. This complexity should be lifted elsewhere.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
"Invocation must have exactly one source file!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
"FIXME: AST inputs not yet supported here!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
Frontend: Add FrontendAction support for handling LLVM IR inputs. - These inputs follow an abbreviated execution path, but are still worth handling by FrontendAction so they reuse all the other clang -cc1 features. llvm-svn: 105582
2010-06-08 07:26:47 +08:00
"IR inputs not support here!");
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
// Configure the various subsystems.
// FIXME: Should we retain the previous file manager?
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
LangOpts = &Clang->getLangOpts();
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
FileSystemOpts = Clang->getFileSystemOpts();
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
FileMgr = new FileManager(FileSystemOpts);
SourceMgr = new SourceManager(getDiagnostics(), *FileMgr);
Teach ASTUnit to hold on to the Sema object and ASTConsumer that are used when parsing (or re-parsing) a file. Also, when loading a precompiled header into ASTUnit, create a Sema object that holds onto semantic-analysis information. llvm-svn: 111003
2010-08-13 11:15:25 +08:00
TheSema.reset();
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Ctx = 0;
PP = 0;
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
Reader = 0;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
// Clear out old caches and data.
TopLevelDecls.clear();
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
clearFileLevelDecls();
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
CleanTemporaryFiles();
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
When we decide not to reuse a precompiled preamble, clear out the previous precompiled preamble completely. Fixes <rdar://problem/8330950>. llvm-svn: 111590
2010-08-20 08:02:33 +08:00
if (!OverrideMainBuffer) {
[libclang] Make sure we don't try to erase past the StoredDiagnostics vector. Ted came upon the bug but I couldn't make a test out of it. llvm-svn: 142805
2011-10-25 01:25:20 +08:00
StoredDiagnostics.erase(stored_diag_afterDriver_begin(), stored_diag_end());
When we decide not to reuse a precompiled preamble, clear out the previous precompiled preamble completely. Fixes <rdar://problem/8330950>. llvm-svn: 111590
2010-08-20 08:02:33 +08:00
TopLevelDeclsInPreamble.clear();
}
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
// Create a file manager object to provide access to and cache the filesystem.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setFileManager(&getFileManager());
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
// Create the source manager.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setSourceManager(&getSourceManager());
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
// If the main file has been overridden due to the use of a preamble,
// make that override happen and introduce the preamble.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
PreprocessorOptions &PreprocessorOpts = Clang->getPreprocessorOpts();
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
PreprocessorOpts.DetailedRecordIncludesNestedMacroExpansions
= NestedMacroExpansions;
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
if (OverrideMainBuffer) {
PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
PreprocessorOpts.PrecompiledPreambleBytes.second
= PreambleEndsAtStartOfLine;
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this);
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
PreprocessorOpts.DisablePCHValidation = true;
Fix use-after-free with precompiled preambles llvm-svn: 109505
2010-07-27 22:52:07 +08:00
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
// The stored diagnostic has the old source manager in it; update
// the locations to refer into the new source manager. Since we've
// been careful to make sure that the source manager's state
// before and after are identical, so that we can reuse the source
// location itself.
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
for (unsigned I = NumStoredDiagnosticsFromDriver,
N = StoredDiagnostics.size();
I < N; ++I) {
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
FullSourceLoc Loc(StoredDiagnostics[I].getLocation(),
getSourceManager());
StoredDiagnostics[I].setLocation(Loc);
}
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
// Keep track of the override buffer;
SavedMainFileBuffer = OverrideMainBuffer;
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
}
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::OwningPtr<TopLevelDeclTrackerAction> Act(
new TopLevelDeclTrackerAction(*this));
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
ActCleanup(Act.get());
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
Clang->getFrontendOpts().Inputs[0].first))
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
goto error;
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
if (OverrideMainBuffer) {
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
std::string ModName = getPreambleFile(this);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
TranslateStoredDiagnostics(Clang->getModuleManager(), ModName,
getSourceManager(), PreambleDiagnostics,
StoredDiagnostics);
}
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
Act->Execute();
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
// Steal the created target, context, and preprocessor.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
TheSema.reset(Clang->takeSema());
Consumer.reset(Clang->takeASTConsumer());
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Ctx = &Clang->getASTContext();
PP = &Clang->getPreprocessor();
Clang->setSourceManager(0);
Clang->setFileManager(0);
Target = &Clang->getTarget();
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
Reader = Clang->getModuleManager();
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
ASTUnit/CIndex: Explicitly track the top-level decls when using an ASTUnit made from a source file. - This allows CIndex to avoid iterating over all the top-level decls when using a PCH, which means we deserialize far fewer decls. llvm-svn: 90559
2009-12-04 16:17:33 +08:00
Act->EndSourceFile();
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
return false;
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
error:
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
// Remove the overridden buffer we used for the preamble.
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
if (OverrideMainBuffer) {
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
delete OverrideMainBuffer;
Fix a double-free error that can occur in rare cases where loading of the precompiled preamble (or any PCH file it depends on) fails during reparsing. llvm-svn: 115838
2010-10-07 05:11:08 +08:00
SavedMainFileBuffer = 0;
Implement -fno-validate-pch at the -cc1 level, which suppresses most of the usual consistency checks used to determine when a precompiled header is incompatible with the translation unit it's being loaded into. Enable this option when loading a precompiled preamble, because the preamble loader will be performing all of this checking itself. Enable the preamble-based test now that it's working. This option is also useful for debugging Clang's PCH (<rdar://problem/7532213>). llvm-svn: 109475
2010-07-27 08:27:13 +08:00
}
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
Parse default arguments within member functions in source order, from Manuel Klimek! Fixes PR7715. llvm-svn: 116311
2010-10-13 00:25:54 +08:00
StoredDiagnostics.clear();
[libclang] Make sure we don't try to erase past the StoredDiagnostics vector. Ted came upon the bug but I couldn't make a test out of it. llvm-svn: 142805
2011-10-25 01:25:20 +08:00
NumStoredDiagnosticsFromDriver = 0;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
return true;
}
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
/// \brief Simple function to retrieve a path for a preamble precompiled header.
static std::string GetPreamblePCHPath() {
// FIXME: This is lame; sys::Path should provide this function (in particular,
// it should know how to find the temporary files dir).
// FIXME: This is really lame. I copied this code from the Driver!
The two libclang crash-recovery tests that involve precompiled preambles end up leaving the precompiled preambles around. This is by design, since we do minimal cleanup during crash recovery. However, it's unfortunate for testing, so introduce a hook that allows these two tests to put the precompiled preamble somewhere where we can delete them after testing. llvm-svn: 113698
2010-09-12 02:05:19 +08:00
// FIXME: This is a hack so that we can override the preamble file during
// crash-recovery testing, which is the only case where the preamble files
// are not necessarily cleaned up.
const char *TmpFile = ::getenv("CINDEXTEST_PREAMBLE_FILE");
if (TmpFile)
return TmpFile;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
std::string Error;
const char *TmpDir = ::getenv("TMPDIR");
if (!TmpDir)
TmpDir = ::getenv("TEMP");
if (!TmpDir)
TmpDir = ::getenv("TMP");
Tweak GetPreamblePCHPath() to more closely match the behavior of the Windows GetTempPath() function, and be sure to create the directory in which the precompiled preamble will reside before creating the temporary file itself. llvm-svn: 113695
2010-09-12 01:51:16 +08:00
#ifdef LLVM_ON_WIN32
if (!TmpDir)
TmpDir = ::getenv("USERPROFILE");
#endif
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
if (!TmpDir)
TmpDir = "/tmp";
llvm::sys::Path P(TmpDir);
Tweak GetPreamblePCHPath() to more closely match the behavior of the Windows GetTempPath() function, and be sure to create the directory in which the precompiled preamble will reside before creating the temporary file itself. llvm-svn: 113695
2010-09-12 01:51:16 +08:00
P.createDirectoryOnDisk(true);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
P.appendComponent("preamble");
Fix a thinko in the creation of temporary files for the precompiled preamble llvm-svn: 110804
2010-08-11 21:06:56 +08:00
P.appendSuffix("pch");
Cut down one open/close pair of system calls by using Path's makeUnique instead of createTemporaryFileOnDisk. llvm-svn: 135690
2011-07-22 02:44:46 +08:00
if (P.makeUnique(/*reuse_current=*/false, /*ErrMsg*/0))
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
return std::string();
return P.str();
}
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
/// \brief Compute the preamble for the main file, providing the source buffer
/// that corresponds to the main file along with a pair (bytes, start-of-line)
/// that describes the preamble.
std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> >
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
ASTUnit::ComputePreamble(CompilerInvocation &Invocation,
unsigned MaxLines, bool &CreatedBuffer) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
FrontendOptions &FrontendOpts = Invocation.getFrontendOpts();
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
PreprocessorOptions &PreprocessorOpts = Invocation.getPreprocessorOpts();
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
CreatedBuffer = false;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Try to determine if the main file has been remapped, either from the
// command line (to another file) or directly through the compiler invocation
// (to a memory buffer).
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
llvm::MemoryBuffer *Buffer = 0;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
if (const llvm::sys::FileStatus *MainFileStatus = MainFilePath.getFileStatus()) {
// Check whether there is a file-file remapping of the main file
for (PreprocessorOptions::remapped_file_iterator
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
M = PreprocessorOpts.remapped_file_begin(),
E = PreprocessorOpts.remapped_file_end();
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
M != E;
++M) {
llvm::sys::PathWithStatus MPath(M->first);
if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
if (MainFileStatus->uniqueID == MStatus->uniqueID) {
// We found a remapping. Try to load the resulting, remapped source.
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
if (CreatedBuffer) {
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
delete Buffer;
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
CreatedBuffer = false;
}
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
Buffer = getBufferForFile(M->second);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
if (!Buffer)
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
return std::make_pair((llvm::MemoryBuffer*)0,
std::make_pair(0, true));
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
CreatedBuffer = true;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
}
}
// Check whether there is a file-buffer remapping. It supercedes the
// file-file remapping.
for (PreprocessorOptions::remapped_file_buffer_iterator
M = PreprocessorOpts.remapped_file_buffer_begin(),
E = PreprocessorOpts.remapped_file_buffer_end();
M != E;
++M) {
llvm::sys::PathWithStatus MPath(M->first);
if (const llvm::sys::FileStatus *MStatus = MPath.getFileStatus()) {
if (MainFileStatus->uniqueID == MStatus->uniqueID) {
// We found a remapping.
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
if (CreatedBuffer) {
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
delete Buffer;
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
CreatedBuffer = false;
}
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
Buffer = const_cast<llvm::MemoryBuffer *>(M->second);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
}
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
}
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
// If the main source file was not remapped, load it now.
if (!Buffer) {
Implement -working-directory. When -working-directory is passed in command line, file paths are resolved relative to the specified directory. This helps both when using libclang (where we can't require the user to actually change the working directory) and to help reproduce test cases when the reproduction work comes along. --FileSystemOptions is introduced which controls how file system operations are performed (currently it just contains the working directory value if set). --FileSystemOptions are passed around to various interfaces that perform file operations. --Opening & reading the content of files should be done only through FileManager. This is useful in general since file operations will be abstracted in the future for the reproduction mechanism. FileSystemOptions is independent of FileManager so that we can have multiple translation units sharing the same FileManager but with different FileSystemOptions. Addresses rdar://8583824. llvm-svn: 118203
2010-11-04 06:45:23 +08:00
Buffer = getBufferForFile(FrontendOpts.Inputs[0].second);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
if (!Buffer)
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
return std::make_pair((llvm::MemoryBuffer*)0, std::make_pair(0, true));
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
CreatedBuffer = true;
}
Make Lexer::ComputePreamble accept a LangOptions parameter, otherwise it may be out-of-sync how a file is compiled. Patch by Matthias Kleine! llvm-svn: 138580
2011-08-26 04:39:19 +08:00
return std::make_pair(Buffer, Lexer::ComputePreamble(Buffer,
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
*Invocation.getLangOpts(),
Make Lexer::ComputePreamble accept a LangOptions parameter, otherwise it may be out-of-sync how a file is compiled. Patch by Matthias Kleine! llvm-svn: 138580
2011-08-26 04:39:19 +08:00
MaxLines));
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
}
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
static llvm::MemoryBuffer *CreatePaddedMainFileBuffer(llvm::MemoryBuffer *Old,
unsigned NewSize,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef NewName) {
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
llvm::MemoryBuffer *Result
= llvm::MemoryBuffer::getNewUninitMemBuffer(NewSize, NewName);
memcpy(const_cast<char*>(Result->getBufferStart()),
Old->getBufferStart(), Old->getBufferSize());
memset(const_cast<char*>(Result->getBufferStart()) + Old->getBufferSize(),
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
' ', NewSize - Old->getBufferSize() - 1);
const_cast<char*>(Result->getBufferEnd())[-1] = '\n';
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return Result;
}
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
/// \brief Attempt to build or re-use a precompiled preamble when (re-)parsing
/// the source file.
///
/// This routine will compute the preamble of the main source file. If a
/// non-trivial preamble is found, it will precompile that preamble into a
/// precompiled header so that the precompiled preamble can be used to reduce
/// reparsing time. If a precompiled preamble has already been constructed,
/// this routine will determine if it is still valid and, if so, avoid
/// rebuilding the precompiled preamble.
///
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
/// \param AllowRebuild When true (the default), this routine is
/// allowed to rebuild the precompiled preamble if it is found to be
/// out-of-date.
///
/// \param MaxLines When non-zero, the maximum number of lines that
/// can occur within the preamble.
///
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
/// \returns If the precompiled preamble can be used, returns a newly-allocated
/// buffer that should be used in place of the main file when doing so.
/// Otherwise, returns a NULL pointer.
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
llvm::MemoryBuffer *ASTUnit::getMainBufferWithPrecompiledPreamble(
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
const CompilerInvocation &PreambleInvocationIn,
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
bool AllowRebuild,
unsigned MaxLines) {
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
llvm::IntrusiveRefCntPtr<CompilerInvocation>
PreambleInvocation(new CompilerInvocation(PreambleInvocationIn));
FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
PreprocessorOptions &PreprocessorOpts
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
= PreambleInvocation->getPreprocessorOpts();
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
bool CreatedPreambleBuffer = false;
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
std::pair<llvm::MemoryBuffer *, std::pair<unsigned, bool> > NewPreamble
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
= ComputePreamble(*PreambleInvocation, MaxLines, CreatedPreambleBuffer);
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// If ComputePreamble() Take ownership of the preamble buffer.
Use an OwningPtr for the preamble buffer in ASTUnit. This plugs a leak where we failed to free this buffer along one of the paths, and detangles the code a little. llvm-svn: 119379
2010-11-17 04:45:51 +08:00
llvm::OwningPtr<llvm::MemoryBuffer> OwnedPreambleBuffer;
if (CreatedPreambleBuffer)
OwnedPreambleBuffer.reset(NewPreamble.first);
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
if (!NewPreamble.second.first) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// We couldn't find a preamble in the main source. Clear out the current
// preamble, if we have one. It's obviously no good any more.
Preamble.clear();
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
erasePreambleFile(this);
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
// The next time we actually see a preamble, precompile it.
PreambleRebuildCounter = 1;
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return 0;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
if (!Preamble.empty()) {
// We've previously computed a preamble. Check whether we have the same
// preamble now that we did before, and that there's enough space in
// the main-file buffer within the precompiled preamble to fit the
// new main file.
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
if (Preamble.size() == NewPreamble.second.first &&
PreambleEndsAtStartOfLine == NewPreamble.second.second &&
Put a newline at the end of the padded buffers used for the precompiled preamble. This will suppress the -pedantic "no newline at end of file" warning. llvm-svn: 109301
2010-07-24 08:42:07 +08:00
NewPreamble.first->getBufferSize() < PreambleReservedSize-2 &&
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
memcmp(Preamble.getBufferStart(), NewPreamble.first->getBufferStart(),
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
NewPreamble.second.first) == 0) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// The preamble has not changed. We may be able to re-use the precompiled
// preamble.
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
// Check that none of the files used by the preamble have changed.
bool AnyFileChanged = false;
// First, make a record of those files that have been overridden via
// remapping or unsaved_files.
llvm::StringMap<std::pair<off_t, time_t> > OverriddenFiles;
for (PreprocessorOptions::remapped_file_iterator
R = PreprocessorOpts.remapped_file_begin(),
REnd = PreprocessorOpts.remapped_file_end();
!AnyFileChanged && R != REnd;
++R) {
struct stat StatBuf;
Use the newly added FileManager::getNoncachedStatValue when trying to determine if any files in the preamble have changed. llvm-svn: 127894
2011-03-19 03:23:38 +08:00
if (FileMgr->getNoncachedStatValue(R->second, StatBuf)) {
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
// If we can't stat the file we're remapping to, assume that something
// horrible happened.
AnyFileChanged = true;
break;
}
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
OverriddenFiles[R->first] = std::make_pair(StatBuf.st_size,
StatBuf.st_mtime);
}
for (PreprocessorOptions::remapped_file_buffer_iterator
R = PreprocessorOpts.remapped_file_buffer_begin(),
REnd = PreprocessorOpts.remapped_file_buffer_end();
!AnyFileChanged && R != REnd;
++R) {
// FIXME: Should we actually compare the contents of file->buffer
// remappings?
OverriddenFiles[R->first] = std::make_pair(R->second->getBufferSize(),
0);
}
// Check whether anything has changed.
for (llvm::StringMap<std::pair<off_t, time_t> >::iterator
F = FilesInPreamble.begin(), FEnd = FilesInPreamble.end();
!AnyFileChanged && F != FEnd;
++F) {
llvm::StringMap<std::pair<off_t, time_t> >::iterator Overridden
= OverriddenFiles.find(F->first());
if (Overridden != OverriddenFiles.end()) {
// This file was remapped; check whether the newly-mapped file
// matches up with the previous mapping.
if (Overridden->second != F->second)
AnyFileChanged = true;
continue;
}
// The file was not remapped; check whether it has changed on disk.
struct stat StatBuf;
Use the newly added FileManager::getNoncachedStatValue when trying to determine if any files in the preamble have changed. llvm-svn: 127894
2011-03-19 03:23:38 +08:00
if (FileMgr->getNoncachedStatValue(F->first(), StatBuf)) {
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
// If we can't stat the file, assume that something horrible happened.
AnyFileChanged = true;
} else if (StatBuf.st_size != F->second.first ||
StatBuf.st_mtime != F->second.second)
AnyFileChanged = true;
}
if (!AnyFileChanged) {
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
// Okay! We can re-use the precompiled preamble.
// Set the state of the diagnostic object to mimic its state
// after parsing the preamble.
getDiagnostics().Reset();
Switch c-index-test from clang_codeComplete() over to clang_codeCompleteAt(). This uncovered a few issues with the latter: - ASTUnit wasn't saving/restoring diagnostic state appropriately between reparses and code completions. - "Overload" completions weren't being passed through to the client llvm-svn: 116241
2010-10-12 05:37:58 +08:00
ProcessWarningOptions(getDiagnostics(),
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
PreambleInvocation->getDiagnosticOpts());
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
getDiagnostics().setNumWarnings(NumWarningsInPreamble);
// Create a version of the main file buffer that is padded to
// buffer size we reserved when creating the preamble.
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
return CreatePaddedMainFileBuffer(NewPreamble.first,
PreambleReservedSize,
FrontendOpts.Inputs[0].second);
}
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
}
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
// If we aren't allowed to rebuild the precompiled preamble, just
// return now.
if (!AllowRebuild)
return 0;
Fix three related, wily issues with the recompilation of precompiled preambles: - When we rebuild a precompiled preamble, make sure to disable skipping anything in the main file; we may have had leftover preamble-skipping values in the lexer, which leads to very empty preamble. This is a correctness issue. - When we rebuild a precompiled preamble, clear out any prior state in the Diagnostic object. Otherwise, we might think that there were errors when we were building the preamble itself, and therefore reject the resulting preamble. This is mainly a performance issue. - Don't remove old remappings when digging out the remapping for the main file. Having the old mappings around does not hurt in the common case (later remappings will just overwrite them), and is important when we fail to find a preamble: we don't want to have removed the remapping, because we'll need it later. llvm-svn: 116041
2010-10-08 12:03:57 +08:00
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// We can't reuse the previously-computed preamble. Build a new one.
Preamble.clear();
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
PreambleDiagnostics.clear();
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
erasePreambleFile(this);
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
PreambleRebuildCounter = 1;
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
} else if (!AllowRebuild) {
// We aren't allowed to rebuild the precompiled preamble; just
// return now.
return 0;
}
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
// If the preamble rebuild counter > 1, it's because we previously
// failed to build a preamble and we're not yet ready to try
// again. Decrement the counter and return a failure.
if (PreambleRebuildCounter > 1) {
--PreambleRebuildCounter;
return 0;
}
If we fail to create a temporary file for the precompiled preamble, just abort creation of the precompiled preamble rather than doing silly things. This is the second part of the fix for the weird preamble-related failures on Windows. Big thanks to Francois Pichet for the great detective work! llvm-svn: 113697
2010-09-12 01:56:52 +08:00
// Create a temporary file for the precompiled preamble. In rare
// circumstances, this can fail.
std::string PreamblePCHPath = GetPreamblePCHPath();
if (PreamblePCHPath.empty()) {
// Try again next time.
PreambleRebuildCounter = 1;
return 0;
}
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// We did not previously compute a preamble, or it can't be reused anyway.
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
SimpleTimer PreambleTimer(WantTiming);
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
PreambleTimer.setOutput("Precompiling preamble");
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Create a new buffer that stores the preamble. The buffer also contains
// extra space for the original contents of the file (which will be present
// when we actually parse the file) along with more room in case the file
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// grows.
PreambleReservedSize = NewPreamble.first->getBufferSize();
if (PreambleReservedSize < 4096)
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
PreambleReservedSize = 8191;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
else
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
PreambleReservedSize *= 2;
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
// Save the preamble text for later; we'll need to compare against it for
// subsequent reparses.
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
StringRef MainFilename = PreambleInvocation->getFrontendOpts().Inputs[0].second;
Preamble.assign(FileMgr->getFile(MainFilename),
NewPreamble.first->getBufferStart(),
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
NewPreamble.first->getBufferStart()
+ NewPreamble.second.first);
PreambleEndsAtStartOfLine = NewPreamble.second.second;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
delete PreambleBuffer;
PreambleBuffer
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
= llvm::MemoryBuffer::getNewUninitMemBuffer(PreambleReservedSize,
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
FrontendOpts.Inputs[0].second);
memcpy(const_cast<char*>(PreambleBuffer->getBufferStart()),
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
NewPreamble.first->getBufferStart(), Preamble.size());
memset(const_cast<char*>(PreambleBuffer->getBufferStart()) + Preamble.size(),
Introduce basic support for loading a precompiled preamble while reparsing an ASTUnit. When saving a preamble, create a buffer larger than the actual file we're working with but fill everything from the end of the preamble to the end of the file with spaces (so the lexer will quickly skip them). When we load the file, create a buffer of the same size, filling it with the file and then spaces. Then, instruct the lexer to start lexing after the preamble, therefore continuing the parse from the spot where the preamble left off. It's now possible to perform a simple preamble build + parse (+ reparse) with ASTUnit. However, one has to disable a bunch of checking in the PCH reader to do so. That part isn't committed; it will likely be handled with some other kind of flag (e.g., -fno-validate-pch). As part of this, fix some issues with null termination of the memory buffers created for the preamble; we were trying to explicitly NULL-terminate them, even though they were also getting implicitly NULL terminated, leading to excess warnings about NULL characters in source files. llvm-svn: 109445
2010-07-27 05:36:20 +08:00
' ', PreambleReservedSize - Preamble.size() - 1);
const_cast<char*>(PreambleBuffer->getBufferEnd())[-1] = '\n';
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Remap the main source file to the preamble buffer.
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
llvm::sys::PathWithStatus MainFilePath(FrontendOpts.Inputs[0].second);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
PreprocessorOpts.addRemappedFile(MainFilePath.str(), PreambleBuffer);
// Tell the compiler invocation to generate a temporary precompiled header.
FrontendOpts.ProgramAction = frontend::GeneratePCH;
// FIXME: Generate the precompiled header into memory?
If we fail to create a temporary file for the precompiled preamble, just abort creation of the precompiled preamble rather than doing silly things. This is the second part of the fix for the weird preamble-related failures on Windows. Big thanks to Francois Pichet for the great detective work! llvm-svn: 113697
2010-09-12 01:56:52 +08:00
FrontendOpts.OutputFile = PreamblePCHPath;
Fix three related, wily issues with the recompilation of precompiled preambles: - When we rebuild a precompiled preamble, make sure to disable skipping anything in the main file; we may have had leftover preamble-skipping values in the lexer, which leads to very empty preamble. This is a correctness issue. - When we rebuild a precompiled preamble, clear out any prior state in the Diagnostic object. Otherwise, we might think that there were errors when we were building the preamble itself, and therefore reject the resulting preamble. This is mainly a performance issue. - Don't remove old remappings when digging out the remapping for the main file. Having the old mappings around does not hurt in the common case (later remappings will just overwrite them), and is important when we fail to find a preamble: we don't want to have removed the remapping, because we'll need it later. llvm-svn: 116041
2010-10-08 12:03:57 +08:00
PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
PreprocessorOpts.PrecompiledPreambleBytes.second = false;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Create the compiler instance to use for building the precompiled preamble.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get());
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
When we create a precompiled preamble, don't copy the CompilerInvocation on the stack, because other objects (e.g., the CompilerInstance) maintain an intrusive reference-counted pointer to the CompilerInvocation. This doesn't matter in the normal case, because we take back the CompilerInvocation. However, during crash recovery, this leads to us trying to free an object on the stack, and hilarity ensues. Fixes <rdar://problem/9652540>. llvm-svn: 134245
2011-07-02 02:22:13 +08:00
Clang->setInvocation(&*PreambleInvocation);
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
// Set up diagnostics, capturing all of the diagnostics produced.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setDiagnostics(&getDiagnostics());
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Create the target instance.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTargetOpts().Features = TargetFeatures;
Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
Clang->getTargetOpts()));
if (!Clang->hasTarget()) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
Preamble.clear();
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
PreambleRebuildCounter = DefaultPreambleRebuildInterval;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
PreprocessorOpts.eraseRemappedFile(
PreprocessorOpts.remapped_file_buffer_end() - 1);
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return 0;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
// Inform the target of the language options.
//
// FIXME: We shouldn't need to do this, the target should be immutable once
// created. This complexity should be lifted elsewhere.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
"Invocation must have exactly one source file!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
"FIXME: AST inputs not yet supported here!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
"IR inputs not support here!");
// Clear out old caches and data.
Fix three related, wily issues with the recompilation of precompiled preambles: - When we rebuild a precompiled preamble, make sure to disable skipping anything in the main file; we may have had leftover preamble-skipping values in the lexer, which leads to very empty preamble. This is a correctness issue. - When we rebuild a precompiled preamble, clear out any prior state in the Diagnostic object. Otherwise, we might think that there were errors when we were building the preamble itself, and therefore reject the resulting preamble. This is mainly a performance issue. - Don't remove old remappings when digging out the remapping for the main file. Having the old mappings around does not hurt in the common case (later remappings will just overwrite them), and is important when we fail to find a preamble: we don't want to have removed the remapping, because we'll need it later. llvm-svn: 116041
2010-10-08 12:03:57 +08:00
getDiagnostics().Reset();
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
ProcessWarningOptions(getDiagnostics(), Clang->getDiagnosticOpts());
[libclang] Make sure we don't try to erase past the StoredDiagnostics vector. Ted came upon the bug but I couldn't make a test out of it. llvm-svn: 142805
2011-10-25 01:25:20 +08:00
StoredDiagnostics.erase(stored_diag_afterDriver_begin(), stored_diag_end());
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
TopLevelDecls.clear();
TopLevelDeclsInPreamble.clear();
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Create a file manager object to provide access to and cache the filesystem.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setFileManager(new FileManager(Clang->getFileSystemOpts()));
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
// Create the source manager.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setSourceManager(new SourceManager(getDiagnostics(),
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Clang->getFileManager()));
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
Reshuffle the PCH generator action and consumer, so that we can re-use it while generating precompiled preambles. No functionality change. llvm-svn: 110108
2010-08-03 16:14:03 +08:00
llvm::OwningPtr<PrecompilePreambleAction> Act;
Act.reset(new PrecompilePreambleAction(*this));
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
if (!Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
Clang->getFrontendOpts().Inputs[0].first)) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
Preamble.clear();
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
PreambleRebuildCounter = DefaultPreambleRebuildInterval;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
PreprocessorOpts.eraseRemappedFile(
PreprocessorOpts.remapped_file_buffer_end() - 1);
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return 0;
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
Act->Execute();
Act->EndSourceFile();
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
if (Diagnostics->hasErrorOccurred()) {
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// There were errors parsing the preamble, so no precompiled header was
// generated. Forget that we even tried.
Remove libclang logging code llvm-svn: 114836
2010-09-28 00:43:25 +08:00
// FIXME: Should we leave a note for ourselves to try again?
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
llvm::sys::Path(FrontendOpts.OutputFile).eraseFromDisk();
Preamble.clear();
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
TopLevelDeclsInPreamble.clear();
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
PreambleRebuildCounter = DefaultPreambleRebuildInterval;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
PreprocessorOpts.eraseRemappedFile(
PreprocessorOpts.remapped_file_buffer_end() - 1);
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return 0;
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
}
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// Transfer any diagnostics generated when parsing the preamble into the set
// of preamble diagnostics.
PreambleDiagnostics.clear();
PreambleDiagnostics.insert(PreambleDiagnostics.end(),
[libclang] Make sure we don't try to erase past the StoredDiagnostics vector. Ted came upon the bug but I couldn't make a test out of it. llvm-svn: 142805
2011-10-25 01:25:20 +08:00
stored_diag_afterDriver_begin(), stored_diag_end());
StoredDiagnostics.erase(stored_diag_afterDriver_begin(), stored_diag_end());
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// Keep track of the preamble we precompiled.
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
setPreambleFile(this, FrontendOpts.OutputFile);
When using a precompiled preamble, save the diagnostics produced when creating the preamble and "replay" them when reusing the preamble. Also, fix a thinko in the copying of the preamble when building the precompiled preamble. llvm-svn: 110061
2010-08-03 04:51:39 +08:00
NumWarningsInPreamble = getDiagnostics().getNumWarnings();
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
// Keep track of all of the files that the source manager knows about,
// so we can verify whether they have changed or not.
FilesInPreamble.clear();
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
SourceManager &SourceMgr = Clang->getSourceManager();
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
const llvm::MemoryBuffer *MainFileBuffer
= SourceMgr.getBuffer(SourceMgr.getMainFileID());
for (SourceManager::fileinfo_iterator F = SourceMgr.fileinfo_begin(),
FEnd = SourceMgr.fileinfo_end();
F != FEnd;
++F) {
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
const FileEntry *File = F->second->OrigEntry;
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
if (!File || F->second->getRawBuffer() == MainFileBuffer)
continue;
FilesInPreamble[File->getName()]
= std::make_pair(F->second->getSize(), File->getModificationTime());
}
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
PreambleRebuildCounter = 1;
Plug a leak when precompiling the preamble in ASTUnit. llvm-svn: 111504
2010-08-19 09:33:06 +08:00
PreprocessorOpts.eraseRemappedFile(
PreprocessorOpts.remapped_file_buffer_end() - 1);
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
// If the hash of top-level entities differs from the hash of the top-level
// entities the last time we rebuilt the preamble, clear out the completion
// cache.
if (CurrentTopLevelHashValue != PreambleTopLevelHashValue) {
CompletionCacheTopLevelHashValue = 0;
PreambleTopLevelHashValue = CurrentTopLevelHashValue;
}
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
return CreatePaddedMainFileBuffer(NewPreamble.first,
PreambleReservedSize,
FrontendOpts.Inputs[0].second);
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
When using a precompiled preamble, keep track of the top-level declarations that we saw when creating the precompiled preamble, and provide those declarations in addition to the declarations parsed in the main source file when traversing top-level declarations. This makes the use of precompiled preambles a pure optimization, rather than changing the semantics of the parsed translation unit. llvm-svn: 110131
2010-08-04 03:06:41 +08:00
void ASTUnit::RealizeTopLevelDeclsFromPreamble() {
std::vector<Decl *> Resolved;
Resolved.reserve(TopLevelDeclsInPreamble.size());
ExternalASTSource &Source = *getASTContext().getExternalSource();
for (unsigned I = 0, N = TopLevelDeclsInPreamble.size(); I != N; ++I) {
// Resolve the declaration ID to an actual declaration, possibly
// deserializing the declaration in the process.
Decl *D = Source.GetExternalDecl(TopLevelDeclsInPreamble[I]);
if (D)
Resolved.push_back(D);
}
TopLevelDeclsInPreamble.clear();
TopLevelDecls.insert(TopLevelDecls.begin(), Resolved.begin(), Resolved.end());
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef ASTUnit::getMainFileName() const {
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
return Invocation->getFrontendOpts().Inputs[0].second;
}
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
ASTUnit *ASTUnit::create(CompilerInvocation *CI,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags) {
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
llvm::OwningPtr<ASTUnit> AST;
AST.reset(new ASTUnit(false));
ConfigureDiags(Diags, 0, 0, *AST, /*CaptureDiagnostics=*/false);
AST->Diagnostics = Diags;
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->Invocation = CI;
Correctly store and keep track of the FileSystemOptions in ASTUnit and in clang_codeCompleteAt. llvm-svn: 127890
2011-03-19 02:22:40 +08:00
AST->FileSystemOpts = CI->getFileSystemOpts();
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->FileMgr = new FileManager(AST->FileSystemOpts);
Allow calling ASTUnit::LoadFromCompilerInvocationAction with a previously created ASTUnit. llvm-svn: 142004
2011-10-15 05:22:05 +08:00
AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr);
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
return AST.take();
}
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(CompilerInvocation *CI,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
Allow calling ASTUnit::LoadFromCompilerInvocationAction with a previously created ASTUnit. llvm-svn: 142004
2011-10-15 05:22:05 +08:00
ASTFrontendAction *Action,
ASTUnit *Unit) {
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
assert(CI && "A CompilerInvocation is required");
Allow calling ASTUnit::LoadFromCompilerInvocationAction with a previously created ASTUnit. llvm-svn: 142004
2011-10-15 05:22:05 +08:00
llvm::OwningPtr<ASTUnit> OwnAST;
ASTUnit *AST = Unit;
if (!AST) {
// Create the AST unit.
OwnAST.reset(create(CI, Diags));
AST = OwnAST.get();
}
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
AST->OnlyLocalDecls = false;
AST->CaptureDiagnostics = false;
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
AST->TUKind = Action ? Action->getTranslationUnitKind() : TU_Complete;
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
AST->ShouldCacheCodeCompletionResults = false;
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
Allow calling ASTUnit::LoadFromCompilerInvocationAction with a previously created ASTUnit. llvm-svn: 142004
2011-10-15 05:22:05 +08:00
ASTUnitCleanup(OwnAST.get());
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
DiagCleanup(Diags.getPtr());
// We'll manage file buffers ourselves.
CI->getPreprocessorOpts().RetainRemappedFileBuffers = true;
CI->getFrontendOpts().DisableFree = false;
ProcessWarningOptions(AST->getDiagnostics(), CI->getDiagnosticOpts());
// Save the target features.
AST->TargetFeatures = CI->getTargetOpts().Features;
// Create the compiler instance to use for building the AST.
llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get());
Clang->setInvocation(CI);
AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
// Set up diagnostics, capturing any diagnostics that would
// otherwise be dropped.
Clang->setDiagnostics(&AST->getDiagnostics());
// Create the target instance.
Clang->getTargetOpts().Features = AST->TargetFeatures;
Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
Clang->getTargetOpts()));
if (!Clang->hasTarget())
return 0;
// Inform the target of the language options.
//
// FIXME: We shouldn't need to do this, the target should be immutable once
// created. This complexity should be lifted elsewhere.
Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
"Invocation must have exactly one source file!");
assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
"FIXME: AST inputs not yet supported here!");
assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
"IR inputs not supported here!");
// Configure the various subsystems.
AST->TheSema.reset();
AST->Ctx = 0;
AST->PP = 0;
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
AST->Reader = 0;
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
// Create a file manager object to provide access to and cache the filesystem.
Clang->setFileManager(&AST->getFileManager());
// Create the source manager.
Clang->setSourceManager(&AST->getSourceManager());
ASTFrontendAction *Act = Action;
llvm::OwningPtr<TopLevelDeclTrackerAction> TrackerAct;
if (!Act) {
TrackerAct.reset(new TopLevelDeclTrackerAction(*AST));
Act = TrackerAct.get();
}
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<TopLevelDeclTrackerAction>
ActCleanup(TrackerAct.get());
if (!Act->BeginSourceFile(*Clang.get(),
Clang->getFrontendOpts().Inputs[0].second,
Clang->getFrontendOpts().Inputs[0].first))
return 0;
Act->Execute();
// Steal the created target, context, and preprocessor.
AST->TheSema.reset(Clang->takeSema());
AST->Consumer.reset(Clang->takeASTConsumer());
AST->Ctx = &Clang->getASTContext();
AST->PP = &Clang->getPreprocessor();
Clang->setSourceManager(0);
Clang->setFileManager(0);
AST->Target = &Clang->getTarget();
Put a reference of the ASTReader in the ASTUnit. This is intended for direct access of the ASTReader for uses that make little sense to try to shoehorn in the ExternalASTSource interface. llvm-svn: 143465
2011-11-02 01:14:15 +08:00
AST->Reader = Clang->getModuleManager();
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
Act->EndSourceFile();
Allow calling ASTUnit::LoadFromCompilerInvocationAction with a previously created ASTUnit. llvm-svn: 142004
2011-10-15 05:22:05 +08:00
if (OwnAST)
return OwnAST.take();
else
return AST;
Introduce ASTUnit::LoadFromCompilerInvocationAction that allows one to create an ASTUnit from a CompilerInvocation along with an ASTFrontendAction to invoke, and without all the goo about the precompiled preamble. llvm-svn: 130805
2011-05-04 07:26:34 +08:00
}
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
bool ASTUnit::LoadFromCompilerInvocation(bool PrecompilePreamble) {
if (!Invocation)
return true;
// We'll manage file buffers ourselves.
Invocation->getPreprocessorOpts().RetainRemappedFileBuffers = true;
Invocation->getFrontendOpts().DisableFree = false;
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
Teach ASTUnit to save the specified target features, since TargetInfo::CreateTargetInfo() mangles the target options in a way that is not idempotent. Fixes <rdar://problem/8807535>. llvm-svn: 124382
2011-01-28 02:02:58 +08:00
// Save the target features.
TargetFeatures = Invocation->getTargetOpts().Features;
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
llvm::MemoryBuffer *OverrideMainBuffer = 0;
Introduce libclang-level options for C++ precompiled preambles, separating out chaining precompiled preambles from non-chaining ones. llvm-svn: 117457
2010-10-28 01:24:53 +08:00
if (PrecompilePreamble) {
Tweak libclang's heuristics for building precompiled preambles and caching global code-completion results. In particular, don't perform either operation the first time we parse, but do both after the first reparse. llvm-svn: 119285
2010-11-16 07:00:34 +08:00
PreambleRebuildCounter = 2;
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
OverrideMainBuffer
= getMainBufferWithPrecompiledPreamble(*Invocation);
}
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
SimpleTimer ParsingTimer(WantTiming);
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
ParsingTimer.setOutput("Parsing " + getMainFileName());
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
// Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<llvm::MemoryBuffer>
MemBufferCleanup(OverrideMainBuffer);
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
return Parse(OverrideMainBuffer);
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
ASTUnit *ASTUnit::LoadFromCompilerInvocation(CompilerInvocation *CI,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
bool OnlyLocalDecls,
Basic plumbing for generating a precompiled preamble for an ASTUnit/CXTranslationUnit. We can't actually use this preamble yet, however. llvm-svn: 109202
2010-07-23 08:33:23 +08:00
bool CaptureDiagnostics,
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
bool PrecompilePreamble,
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
TranslationUnitKind TUKind,
Introduce a new libclang parsing flag, CXTranslationUnit_NestedMacroInstantiations, which indicates whether we want to see "nested" macro instantiations (e.g., those that occur inside other macro instantiations) within the detailed preprocessing record. Many clients (e.g., those that only care about visible tokens) don't care about this information, and in code that uses preprocessor metaprogramming, this information can have a very high cost. Addresses <rdar://problem/9389320>. llvm-svn: 130990
2011-05-07 00:33:08 +08:00
bool CacheCodeCompletionResults,
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
bool NestedMacroExpansions) {
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
// Create the AST unit.
llvm::OwningPtr<ASTUnit> AST;
AST.reset(new ASTUnit(false));
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
ConfigureDiags(Diags, 0, 0, *AST, CaptureDiagnostics);
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
AST->Diagnostics = Diags;
AST->OnlyLocalDecls = OnlyLocalDecls;
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
AST->CaptureDiagnostics = CaptureDiagnostics;
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
AST->TUKind = TUKind;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->Invocation = CI;
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
AST->NestedMacroExpansions = NestedMacroExpansions;
Add some timers to ASTUnit that are only enabled when the LIBCLANG_TIMING environment variable is set. llvm-svn: 109890
2010-07-31 04:58:08 +08:00
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
ASTUnitCleanup(AST.get());
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<DiagnosticsEngine,
llvm::CrashRecoveryContextReleaseRefCleanup<DiagnosticsEngine> >
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
DiagCleanup(Diags.getPtr());
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
return AST->LoadFromCompilerInvocation(PrecompilePreamble)? 0 : AST.take();
Add ASTUnit::LoadFromCompilerInvocation, which does what it says. Also, add an -ast-from-source option to index-test which allows index-test to run on source files directly. llvm-svn: 90223
2009-12-01 17:51:01 +08:00
}
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
ASTUnit *ASTUnit::LoadFromCommandLine(const char **ArgBegin,
const char **ArgEnd,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
llvm::IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef ResourceFilesPath,
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
bool OnlyLocalDecls,
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
bool CaptureDiagnostics,
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
RemappedFile *RemappedFiles,
Rework how CIndex handles diagnostics. Rather than using a callback, we attach diagnostics to translation units and code-completion results, so they can be queried at any time. To facilitate this, the new StoredDiagnostic class stores a diagnostic in a serializable/deserializable form, and ASTUnit knows how to capture diagnostics in this stored form. CIndex's CXDiagnostic is a thin wrapper around StoredDiagnostic, providing a C interface to stored or de-serialized diagnostics. I've XFAIL'd one test case temporarily, because currently we end up storing diagnostics in an ASTUnit that's never returned to the user (because it contains errors). I'll introduce a temporary fix for this soon; the real fix will be to allow us to return and query invalid ASTs. llvm-svn: 96592
2010-02-19 02:08:43 +08:00
unsigned NumRemappedFiles,
Add 'OverridenFilesKeepOriginalName' field in SourceManager which if true the SourceManager should report the original file name for contents of files that were overriden by other files, otherwise it should report the name of the new file. Default is true. Also add similar field in PreprocessorOptions and pass similar parameter in ASTUnit::LoadFromCommandLine. llvm-svn: 127289
2011-03-09 07:35:24 +08:00
bool RemappedFilesKeepOriginalName,
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
bool PrecompilePreamble,
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
TranslationUnitKind TUKind,
Introduce libclang-level options for C++ precompiled preambles, separating out chaining precompiled preambles from non-chaining ones. llvm-svn: 117457
2010-10-28 01:24:53 +08:00
bool CacheCodeCompletionResults,
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
bool NestedMacroExpansions) {
Make Diagnostic reference-counted, which is simpler than juggling maybe-ownership vs. ownership. llvm-svn: 100498
2010-04-06 07:52:57 +08:00
if (!Diags.getPtr()) {
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
// No diagnostics engine was provided, so create our own diagnostics object
// with the default options.
DiagnosticOptions DiagOpts;
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
Diags = CompilerInstance::createDiagnostics(DiagOpts, ArgEnd - ArgBegin,
ArgBegin);
Clarify the ownership semantics of the Diagnostic object used by ASTUnit. Previously, we would end up with use-after-free errors because the Diagnostic object would be creating in one place (say, CIndex) and its ownership would not be transferred into the ASTUnit. Fixes <rdar://problem/7818608>. llvm-svn: 100464
2010-04-06 05:10:19 +08:00
}
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
llvm::IntrusiveRefCntPtr<CompilerInvocation> CI;
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
{
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
CaptureDroppedDiagnostics Capture(CaptureDiagnostics, *Diags,
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
StoredDiagnostics);
Move Driver::createInvocationFromArgs function to Frontend library to avoid dependency cycle between libFrontend and libDriver. llvm-svn: 128852
2011-04-05 07:11:45 +08:00
CI = clang::createInvocationFromCommandLine(
Migrate LLVM and Clang to use the new makeArrayRef(...) functions where previously explicit non-default constructors were used. Mostly mechanical with some manual reformatting. llvm-svn: 135390
2011-07-18 20:00:32 +08:00
llvm::makeArrayRef(ArgBegin, ArgEnd),
Diags);
Introduce Driver::createInvocationFromArgs used to create a CompilerInvocation from command-line args. llvm-svn: 128848
2011-04-05 05:38:51 +08:00
if (!CI)
Allow passing '-###' to ASTUnit::LoadFromCommandLine to print out the cc1 options. llvm-svn: 127183
2011-03-08 06:45:01 +08:00
return 0;
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
}
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
// Override any files that need remapping
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
for (unsigned I = 0; I != NumRemappedFiles; ++I) {
FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
if (const llvm::MemoryBuffer *
memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, memBuf);
} else {
const char *fname = fileOrBuf.get<const char *>();
CI->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first, fname);
}
}
Add 'OverridenFilesKeepOriginalName' field in SourceManager which if true the SourceManager should report the original file name for contents of files that were overriden by other files, otherwise it should report the name of the new file. Default is true. Also add similar field in PreprocessorOptions and pass similar parameter in ASTUnit::LoadFromCommandLine. llvm-svn: 127289
2011-03-09 07:35:24 +08:00
CI->getPreprocessorOpts().RemappedFilesKeepOriginalName =
RemappedFilesKeepOriginalName;
Extend clang_createTranslationUnitFromSourceFile() to support creating translation units that include unsaved files. llvm-svn: 94258
2010-01-23 08:14:00 +08:00
Add -resource-dir to clang -cc1, this allows the base directory for compiler resources (e.g., /usr/lib/clang/1.1) to be passed on the command line instead of computed. llvm-svn: 91370
2009-12-15 08:06:45 +08:00
// Override the resources path.
ASTUnit: Ensure the CompilerInvocation object used in LoadFromCommandLine is live as long as the ASTUnit. This is useful for clients which want to maintain pointers to the LangOptions object which ultimately lives in the CompilerInvocation, although it would be nice to make all of this ownership stuff more explicit and obvious. llvm-svn: 94924
2010-01-31 05:47:16 +08:00
CI->getHeaderSearchOpts().ResourceDir = ResourceFilesPath;
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
// Create the AST unit.
llvm::OwningPtr<ASTUnit> AST;
AST.reset(new ASTUnit(false));
Don't silently drop warning flags passed in to clang_createTranslationUnitFromSourceFile(). llvm-svn: 123793
2011-01-19 09:02:47 +08:00
ConfigureDiags(Diags, ArgBegin, ArgEnd, *AST, CaptureDiagnostics);
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
AST->Diagnostics = Diags;
Simplify crash cleanup logic in ASTUnit::LoadFromCommandLine() by zeroing out two IntrusiveRefCnt pointers after we have assigned their respective values into fields of ASTUnit. llvm-svn: 144929
2011-11-18 07:01:17 +08:00
Diags = 0; // Zero out now to ease cleanup during crash recovery.
Correctly store and keep track of the FileSystemOptions in ASTUnit and in clang_codeCompleteAt. llvm-svn: 127890
2011-03-19 02:22:40 +08:00
AST->FileSystemOpts = CI->getFileSystemOpts();
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->FileMgr = new FileManager(AST->FileSystemOpts);
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
AST->OnlyLocalDecls = OnlyLocalDecls;
Improve ASTUnit's capture of diagnostics so that the diagnostic-capturing client lives as long as the ASTUnit itself does. Otherwise, we can end up with crashes when we get a diagnostic outside of parsing/code completion. The circumstances under which this happen are really hard to reproduce, because a file needs to change from under us. llvm-svn: 118751
2010-11-11 08:39:14 +08:00
AST->CaptureDiagnostics = CaptureDiagnostics;
Introduce a -cc1 option "-emit-module", that creates a binary module from the given source. -emit-module behaves similarly to -emit-pch, except that Sema is somewhat more strict about the contents of -emit-module. In the future, there are likely to be more interesting differences. llvm-svn: 138595
2011-08-26 06:30:56 +08:00
AST->TUKind = TUKind;
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
AST->NumStoredDiagnosticsFromDriver = StoredDiagnostics.size();
AST->StoredDiagnostics.swap(StoredDiagnostics);
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
AST->Invocation = CI;
Simplify crash cleanup logic in ASTUnit::LoadFromCommandLine() by zeroing out two IntrusiveRefCnt pointers after we have assigned their respective values into fields of ASTUnit. llvm-svn: 144929
2011-11-18 07:01:17 +08:00
CI = 0; // Zero out now to ease cleanup during crash recovery.
NestedMacroInstantiations -> NestedMacroExpansions This is switches all the interfaces points (and most of the commenst / local variables I saw on my way through) regarding the NestedMacroInstantiations bit. The libclang enums corresponding to this state were renamed, but a legacy enum was added with the old name, and the same value to keep existing clients working. I've added a documentation blurb for it, but let me know if there is a canonical way to document legacy elemenst of the libclang interface. No functionality changed here, even in tests. llvm-svn: 135141
2011-07-14 17:02:10 +08:00
AST->NestedMacroExpansions = NestedMacroExpansions;
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<ASTUnit>
ASTUnitCleanup(AST.get());
Use CrashRecoveryContextCleanup objects to recover an ASTUnit if we crash in ASTUnit::LoadFromCommandLine() and ASTUnit::LoadFromCompilerInvocation(). llvm-svn: 127851
2011-03-18 10:06:56 +08:00
now the FileManager has a FileSystemOpts ivar, stop threading FileSystemOpts through a ton of apis, simplifying a lot of code. This also fixes a latent bug in ASTUnit where it would invoke methods on FileManager without creating one in some code paths in cindextext. llvm-svn: 120010
2010-11-23 16:35:12 +08:00
return AST->LoadFromCompilerInvocation(PrecompilePreamble) ? 0 : AST.take();
Add ASTUnit::LoadFromCommandLine, which creates an ASTUnit out of a list of (clang/driver) command line arguments (including the source file). - The arguments are expected to include the source file. - The idea is that even though this is a somewhat odd API, its the form which many tools can most easily use (for example, by interposing with the compiler). Also, switch index-test's -ast-from-source to use this entry point, and provide a -arg command line argument which can be used to test that the command line arguments are handled correctly. llvm-svn: 90288
2009-12-02 11:23:45 +08:00
}
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
bool ASTUnit::Reparse(RemappedFile *RemappedFiles, unsigned NumRemappedFiles) {
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
if (!Invocation)
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
return true;
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
clearFileLevelDecls();
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
SimpleTimer ParsingTimer(WantTiming);
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
ParsingTimer.setOutput("Reparsing " + getMainFileName());
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
// Remap files.
When we decide not to reuse a precompiled preamble, clear out the previous precompiled preamble completely. Fixes <rdar://problem/8330950>. llvm-svn: 111590
2010-08-20 08:02:33 +08:00
PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
PPOpts.DisableStatCache = true;
When we decide not to reuse a precompiled preamble, clear out the previous precompiled preamble completely. Fixes <rdar://problem/8330950>. llvm-svn: 111590
2010-08-20 08:02:33 +08:00
for (PreprocessorOptions::remapped_file_buffer_iterator
R = PPOpts.remapped_file_buffer_begin(),
REnd = PPOpts.remapped_file_buffer_end();
R != REnd;
++R) {
delete R->second;
}
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
Invocation->getPreprocessorOpts().clearRemappedFiles();
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
for (unsigned I = 0; I != NumRemappedFiles; ++I) {
FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
if (const llvm::MemoryBuffer *
memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
memBuf);
} else {
const char *fname = fileOrBuf.get<const char *>();
Invocation->getPreprocessorOpts().addRemappedFile(RemappedFiles[I].first,
fname);
}
}
Implement dependency analysis for the precompiled preamble. If any of the files in the precompiled preamble have changed since it was build, force the preamble to be rebuilt. llvm-svn: 109937
2010-07-31 08:40:00 +08:00
When we try (but fail) to build a precompiled preamble, wait for a short "cooling off" period (defaulting to 5 reparses) before trying to build a precompiled preamble again. Previously, if we failed to build the precompiled preamble at any time, we just gave up the whole charade any never tried again. llvm-svn: 110187
2010-08-04 13:53:38 +08:00
// If we have a preamble file lying around, or if we might try to
// build a precompiled preamble, do so now.
Once we've built (or reused) a precompiled preamble, create the appropriately-padded main file buffer (that has spaces in the extra "reserved" space) and thread that buffer through to the parsing function. This still does nothing. llvm-svn: 109299
2010-07-24 08:38:13 +08:00
llvm::MemoryBuffer *OverrideMainBuffer = 0;
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
if (!getPreambleFile(this).empty() || PreambleRebuildCounter > 0)
When performing code-completion in the presence of a preamble, make sure to (1) actually use the remapped files we were given rather than old data, and (2) keep the remapped files alive until the code-completion results are destroyed. Big thanks to Daniel for the test case. llvm-svn: 111597
2010-08-20 08:59:43 +08:00
OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(*Invocation);
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
// Clear out the diagnostics state.
[libclang] Fix crash when a #pragma diagnostic is included in the preamble. A PCH file keeps track of #pragma diagnostics state; when loading the preamble, they conflicted with the #pragma diagnostic state already present in the DiagnosticsEngine object due to parsing the preamble. Fix this by clearing the state of the DiagnosticsEngine object. Fixes rdar://10363572 && http://llvm.org/PR11254. llvm-svn: 143644
2011-11-04 04:28:19 +08:00
getDiagnostics().Reset();
ProcessWarningOptions(getDiagnostics(), Invocation->getDiagnosticOpts());
After resetting the diagnostic state, set the number of warning occurring in the preamble. llvm-svn: 143647
2011-11-04 04:57:33 +08:00
if (OverrideMainBuffer)
getDiagnostics().setNumWarnings(NumWarningsInPreamble);
[libclang] Fix crash when a #pragma diagnostic is included in the preamble. A PCH file keeps track of #pragma diagnostics state; when loading the preamble, they conflicted with the #pragma diagnostic state already present in the DiagnosticsEngine object due to parsing the preamble. Fix this by clearing the state of the DiagnosticsEngine object. Fixes rdar://10363572 && http://llvm.org/PR11254. llvm-svn: 143644
2011-11-04 04:28:19 +08:00
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
// Parse the sources
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
bool Result = Parse(OverrideMainBuffer);
Revert r143342. Caching of code-completion results was intentionally placed in "reparse" because we don't want to take this performance hit when doing code completion Log of r143342: Move caching of code-completion results from ASTUnit::Reparse to ASTUnit::CodeComplete, so that it will happen when we are doing code-completion, not reparsing. llvm-svn: 143367
2011-11-01 05:25:31 +08:00
// If we're caching global code-completion results, and the top-level
// declarations have changed, clear out the code-completion cache.
if (!Result && ShouldCacheCodeCompletionResults &&
CurrentTopLevelHashValue != CompletionCacheTopLevelHashValue)
CacheCodeCompletionResults();
Improve the invalidation logic for the cache of global code completions. We now compute a hash of the names of all top-level declarations and macro definitions, and invalidate the cache when the hash value changes. llvm-svn: 125670
2011-02-17 02:16:54 +08:00
Add a new libclang API to return a CXCompletionString for an arbitrary cursor, from Connor Wakamo! Addresses <rdar://problem/9087798>. llvm-svn: 136911
2011-08-05 04:04:59 +08:00
// We now need to clear out the completion allocator for
// clang_getCursorCompletionString; it'll be recreated if necessary.
CursorCompletionAllocator = 0;
Once we've built a precompiled preamble, keep track of the details of that preamble (the preamble text, preamble file, reserved main file size). Check these details when we try to rebuild the precompiled preamble, and when nothing has changed, re-use the precompiled preamble. This code is still very much a WIP, and can't even properly be tested because we have no way to use the precompiled preamble yet. "Trust me" llvm-svn: 109294
2010-07-24 07:58:40 +08:00
return Result;
Introduce a new libclang API, clang_reparseTranslationUnit(), which reparses an already-parsed translation unit. At the moment it's just a convenience function, but we hope to use it for performance optimizations. llvm-svn: 108756
2010-07-20 05:46:24 +08:00
}
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
//----------------------------------------------------------------------------//
// Code completion
//----------------------------------------------------------------------------//
namespace {
/// \brief Code completion consumer that combines the cached code-completion
/// results from an ASTUnit with the code-completion results provided to it,
/// then passes the result on to
class AugmentedCodeCompleteConsumer : public CodeCompleteConsumer {
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
unsigned long long NormalContexts;
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
ASTUnit &AST;
CodeCompleteConsumer &Next;
public:
AugmentedCodeCompleteConsumer(ASTUnit &AST, CodeCompleteConsumer &Next,
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
bool IncludeMacros, bool IncludeCodePatterns,
bool IncludeGlobals)
: CodeCompleteConsumer(IncludeMacros, IncludeCodePatterns, IncludeGlobals,
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
Next.isOutputBinary()), AST(AST), Next(Next)
{
// Compute the set of contexts in which we will look when we don't have
// any information about the specific context.
NormalContexts
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
= (1LL << (CodeCompletionContext::CCC_TopLevel - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCInterface - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCImplementation - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCIvarList - 1))
| (1LL << (CodeCompletionContext::CCC_Statement - 1))
| (1LL << (CodeCompletionContext::CCC_Expression - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCMessageReceiver - 1))
| (1LL << (CodeCompletionContext::CCC_DotMemberAccess - 1))
| (1LL << (CodeCompletionContext::CCC_ArrowMemberAccess - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCPropertyAccess - 1))
| (1LL << (CodeCompletionContext::CCC_ObjCProtocolName - 1))
| (1LL << (CodeCompletionContext::CCC_ParenthesizedExpression - 1))
| (1LL << (CodeCompletionContext::CCC_Recovery - 1));
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
if (AST.getASTContext().getLangOptions().CPlusPlus)
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
NormalContexts |= (1LL << (CodeCompletionContext::CCC_EnumTag - 1))
| (1LL << (CodeCompletionContext::CCC_UnionTag - 1))
| (1LL << (CodeCompletionContext::CCC_ClassOrStructTag - 1));
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
}
virtual void ProcessCodeCompleteResults(Sema &S,
CodeCompletionContext Context,
Teach Sema to live without CodeCompleteConsumer.h. llvm-svn: 112028
2010-08-25 14:19:51 +08:00
CodeCompletionResult *Results,
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
unsigned NumResults);
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
virtual void ProcessOverloadCandidates(Sema &S, unsigned CurrentArg,
OverloadCandidate *Candidates,
unsigned NumCandidates) {
Next.ProcessOverloadCandidates(S, CurrentArg, Candidates, NumCandidates);
}
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
Create a special allocator class for code completion, so that all of the string copying goes through a single place that can have associated state. llvm-svn: 124698
2011-02-02 06:57:45 +08:00
virtual CodeCompletionAllocator &getAllocator() {
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
return Next.getAllocator();
}
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
};
}
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
/// \brief Helper function that computes which global names are hidden by the
/// local code-completion results.
Change the StringSet used by CalculateHiddenNames() to use a BumpPtrAllocator. llvm-svn: 118372
2010-11-07 14:11:36 +08:00
static void CalculateHiddenNames(const CodeCompletionContext &Context,
CodeCompletionResult *Results,
unsigned NumResults,
ASTContext &Ctx,
llvm::StringSet<llvm::BumpPtrAllocator> &HiddenNames){
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
bool OnlyTagNames = false;
switch (Context.getKind()) {
Synchronize globally-cached code completion results with the results provided when the optimization is disabled. In particular, split the completion context CCC_Other into two contexts: CCC_Other, which means that it's an undisclosed context for which any other results are unwelcome, and CCC_Recovery, which is used in recovery cases. Since we're now using the completion context within the completion results builder, make sure that it's always set to something. Fixes <rdar://problem/8470644>. llvm-svn: 114704
2010-09-24 07:01:17 +08:00
case CodeCompletionContext::CCC_Recovery:
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
case CodeCompletionContext::CCC_TopLevel:
case CodeCompletionContext::CCC_ObjCInterface:
case CodeCompletionContext::CCC_ObjCImplementation:
case CodeCompletionContext::CCC_ObjCIvarList:
case CodeCompletionContext::CCC_ClassStructUnion:
case CodeCompletionContext::CCC_Statement:
case CodeCompletionContext::CCC_Expression:
case CodeCompletionContext::CCC_ObjCMessageReceiver:
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
case CodeCompletionContext::CCC_DotMemberAccess:
case CodeCompletionContext::CCC_ArrowMemberAccess:
case CodeCompletionContext::CCC_ObjCPropertyAccess:
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
case CodeCompletionContext::CCC_Namespace:
case CodeCompletionContext::CCC_Type:
Introduce a new code-completion point when we're parsing a declarator. Here, we can only see a few things (e.g., cvr-qualifiers, nested name specifiers) and we do not want to provide other non-macro completions. Previously, we would end up in recovery mode and would provide a large number of non-relevant completions. llvm-svn: 111818
2010-08-24 02:23:48 +08:00
case CodeCompletionContext::CCC_Name:
case CodeCompletionContext::CCC_PotentiallyQualifiedName:
Introduce a new code-completion context for a parenthesized expression, e.g., after the '(' that could also be a type cast. Here, we provide types as code-completion results in C/Objective-C (C++ already had them), although we wouldn't in a normal expression context. llvm-svn: 113904
2010-09-15 07:59:36 +08:00
case CodeCompletionContext::CCC_ParenthesizedExpression:
When performing code completion after at @interface, allow both already-defined and forward-declared results. Already-defined results are fine because they could be the start of a category. Fixes <rdar://problem/9811691>. llvm-svn: 136559
2011-07-30 14:55:39 +08:00
case CodeCompletionContext::CCC_ObjCInterfaceName:
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
break;
case CodeCompletionContext::CCC_EnumTag:
case CodeCompletionContext::CCC_UnionTag:
case CodeCompletionContext::CCC_ClassOrStructTag:
OnlyTagNames = true;
break;
case CodeCompletionContext::CCC_ObjCProtocolName:
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
case CodeCompletionContext::CCC_MacroName:
case CodeCompletionContext::CCC_MacroNameUse:
Implement code completion for preprocessor expressions and in macro arguments. llvm-svn: 111976
2010-08-25 06:20:20 +08:00
case CodeCompletionContext::CCC_PreprocessorExpression:
When combining the code-completion results from Sema long with the code-completion results cached by ASTUnit, sort the resulting result set. This makes testing far, far easier, so this commit also includes tests for the previous few fixes. llvm-svn: 112070
2010-08-26 02:41:16 +08:00
case CodeCompletionContext::CCC_PreprocessorDirective:
Add a missing case llvm-svn: 112065
2010-08-26 02:04:30 +08:00
case CodeCompletionContext::CCC_NaturalLanguage:
Implement code completion for @selector expressions llvm-svn: 112186
2010-08-26 23:07:07 +08:00
case CodeCompletionContext::CCC_SelectorName:
Suggest "const" and "volatile" code completions after a function declarator, the very definition of "low-hanging fruit". llvm-svn: 112274
2010-08-28 01:35:51 +08:00
case CodeCompletionContext::CCC_TypeQualifiers:
Synchronize globally-cached code completion results with the results provided when the optimization is disabled. In particular, split the completion context CCC_Other into two contexts: CCC_Other, which means that it's an undisclosed context for which any other results are unwelcome, and CCC_Recovery, which is used in recovery cases. Since we're now using the completion context within the completion results builder, make sure that it's always set to something. Fixes <rdar://problem/8470644>. llvm-svn: 114704
2010-09-24 07:01:17 +08:00
case CodeCompletionContext::CCC_Other:
When code-completing a case statement for a switch on a value of enumeration type, prioritize the enumeration constants and don't provide completions for any other expressions. Fixes <rdar://problem/7283668>. llvm-svn: 125991
2011-02-19 07:30:37 +08:00
case CodeCompletionContext::CCC_OtherWithMacros:
Introduce a new libclang aPI function, clang_codeCompleteGetContexts(), that provides the client with information about the context in which code completion has occurred and what kinds of entities make sense as completions at that point. Patch by Connor Wakamo! llvm-svn: 134615
2011-07-08 00:03:39 +08:00
case CodeCompletionContext::CCC_ObjCInstanceMessage:
case CodeCompletionContext::CCC_ObjCClassMessage:
case CodeCompletionContext::CCC_ObjCCategoryName:
When combining the code-completion results from Sema long with the code-completion results cached by ASTUnit, sort the resulting result set. This makes testing far, far easier, so this commit also includes tests for the previous few fixes. llvm-svn: 112070
2010-08-26 02:41:16 +08:00
// We're looking for nothing, or we're looking for names that cannot
// be hidden.
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
return;
}
Teach Sema to live without CodeCompleteConsumer.h. llvm-svn: 112028
2010-08-25 14:19:51 +08:00
typedef CodeCompletionResult Result;
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
for (unsigned I = 0; I != NumResults; ++I) {
if (Results[I].Kind != Result::RK_Declaration)
continue;
unsigned IDNS
= Results[I].Declaration->getUnderlyingDecl()->getIdentifierNamespace();
bool Hiding = false;
if (OnlyTagNames)
Hiding = (IDNS & Decl::IDNS_Tag);
else {
unsigned HiddenIDNS = (Decl::IDNS_Type | Decl::IDNS_Member |
Implement support for cached code completions for nested-name-specifiers. Also includes fixes to the generation of nested-name-specifier result in the non-cached case; we were producing lame results for namespaces and namespace aliases, which (1) didn't always have nested-name-specifiers when we want them, and (2) did not have the necessary "::" as part of the completion. llvm-svn: 111203
2010-08-17 07:05:20 +08:00
Decl::IDNS_Namespace | Decl::IDNS_Ordinary |
Decl::IDNS_NonMemberOperator);
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
if (Ctx.getLangOptions().CPlusPlus)
HiddenIDNS |= Decl::IDNS_Tag;
Hiding = (IDNS & HiddenIDNS);
}
if (!Hiding)
continue;
DeclarationName Name = Results[I].Declaration->getDeclName();
if (IdentifierInfo *Identifier = Name.getAsIdentifierInfo())
HiddenNames.insert(Identifier->getName());
else
HiddenNames.insert(Name.getAsString());
}
}
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
void AugmentedCodeCompleteConsumer::ProcessCodeCompleteResults(Sema &S,
CodeCompletionContext Context,
Teach Sema to live without CodeCompleteConsumer.h. llvm-svn: 112028
2010-08-25 14:19:51 +08:00
CodeCompletionResult *Results,
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
unsigned NumResults) {
// Merge the results we were given with the results we cached.
bool AddedResult = false;
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
unsigned InContexts
Synchronize globally-cached code completion results with the results provided when the optimization is disabled. In particular, split the completion context CCC_Other into two contexts: CCC_Other, which means that it's an undisclosed context for which any other results are unwelcome, and CCC_Recovery, which is used in recovery cases. Since we're now using the completion context within the completion results builder, make sure that it's always set to something. Fixes <rdar://problem/8470644>. llvm-svn: 114704
2010-09-24 07:01:17 +08:00
= (Context.getKind() == CodeCompletionContext::CCC_Recovery? NormalContexts
[MSVC] Fix a warning C4334 "'operator' : result of 32-bit shift implicitly converted to 64 bits (was 64-bit shift intended?)". llvm-svn: 137803
2011-08-17 09:46:16 +08:00
: (1ULL << (Context.getKind() - 1)));
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
// Contains the set of names that are hidden by "local" completion results.
Change the StringSet used by CalculateHiddenNames() to use a BumpPtrAllocator. llvm-svn: 118372
2010-11-07 14:11:36 +08:00
llvm::StringSet<llvm::BumpPtrAllocator> HiddenNames;
Teach Sema to live without CodeCompleteConsumer.h. llvm-svn: 112028
2010-08-25 14:19:51 +08:00
typedef CodeCompletionResult Result;
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<Result, 8> AllResults;
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
for (ASTUnit::cached_completion_iterator
Formatting fixes. No functionality change llvm-svn: 111186
2010-08-17 05:23:13 +08:00
C = AST.cached_completion_begin(),
CEnd = AST.cached_completion_end();
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
C != CEnd; ++C) {
// If the context we are in matches any of the contexts we are
// interested in, we'll add this result.
if ((C->ShowInContexts & InContexts) == 0)
continue;
// If we haven't added any results previously, do so now.
if (!AddedResult) {
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
CalculateHiddenNames(Context, Results, NumResults, S.Context,
HiddenNames);
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
AllResults.insert(AllResults.end(), Results, Results + NumResults);
AddedResult = true;
}
Implement name hiding of cached global code-completion results. llvm-svn: 111184
2010-08-17 05:18:39 +08:00
// Determine whether this global completion result is hidden by a local
// completion result. If so, skip it.
if (C->Kind != CXCursor_MacroDefinition &&
HiddenNames.count(C->Completion->getTypedText()))
continue;
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
// Adjust priority based on similar type classes.
unsigned Priority = C->Priority;
Make the cursor kind of macro-name-only completions produced by ASTUnit match those produced directly by code completion. Test case is forthcoming. llvm-svn: 112063
2010-08-26 02:03:13 +08:00
CXCursorKind CursorKind = C->Kind;
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
CodeCompletionString *Completion = C->Completion;
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
if (!Context.getPreferredType().isNull()) {
if (C->Kind == CXCursor_MacroDefinition) {
Priority = getMacroUsagePriority(C->Completion->getTypedText(),
Tweak priorities for some types and macros: - In Objective-C, we prefer BOOL to bool for historic reasons; slightly penalize "bool". - Treat Nil macro as a NULL pointer constant. - Treat YES, NO, true, and false macros as constants. - Treat the bool macro as a type. llvm-svn: 114356
2010-09-21 05:11:48 +08:00
S.getLangOptions(),
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
Context.getPreferredType()->isAnyPointerType());
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
} else if (C->Type) {
CanQualType Expected
Formatting fixes. No functionality change llvm-svn: 111186
2010-08-17 05:23:13 +08:00
= S.Context.getCanonicalType(
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
Context.getPreferredType().getUnqualifiedType());
SimplifiedTypeClass ExpectedSTC = getSimplifiedTypeClass(Expected);
if (ExpectedSTC == C->TypeClass) {
// We know this type is similar; check for an exact match.
llvm::StringMap<unsigned> &CachedCompletionTypes
Formatting fixes. No functionality change llvm-svn: 111186
2010-08-17 05:23:13 +08:00
= AST.getCachedCompletionTypes();
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
llvm::StringMap<unsigned>::iterator Pos
Formatting fixes. No functionality change llvm-svn: 111186
2010-08-17 05:23:13 +08:00
= CachedCompletionTypes.find(QualType(Expected).getAsString());
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
if (Pos != CachedCompletionTypes.end() && Pos->second == C->Type)
Priority /= CCF_ExactTypeMatch;
else
Priority /= CCF_SimilarTypeMatch;
}
}
}
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
// Adjust the completion string, if required.
if (C->Kind == CXCursor_MacroDefinition &&
Context.getKind() == CodeCompletionContext::CCC_MacroNameUse) {
// Create a new code-completion string that just contains the
// macro name, without its arguments.
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
CodeCompletionBuilder Builder(getAllocator(), CCP_CodePattern,
C->Availability);
Builder.AddTypedTextChunk(C->Completion->getTypedText());
Make the cursor kind of macro-name-only completions produced by ASTUnit match those produced directly by code completion. Test case is forthcoming. llvm-svn: 112063
2010-08-26 02:03:13 +08:00
CursorKind = CXCursor_NotImplemented;
Priority = CCP_CodePattern;
Allocate CodeCompletionString and all of its components in a BumpPtrAllocator, rather than manually new/delete'ing them. This optimization also allows us to avoid allocating memory for and copying constant strings (e.g., "return", "class"). This also required embedding the priority and availability of results within the code completion string, to avoid extra memory allocation within libclang. llvm-svn: 124673
2011-02-02 03:23:04 +08:00
Completion = Builder.TakeString();
Implement preprocessor code completion where a macro name is expected, e.g., after #ifdef/#ifndef or #undef, or inside a defined <macroname> expression in a preprocessor conditional. llvm-svn: 111954
2010-08-25 04:21:13 +08:00
}
Make the cursor kind of macro-name-only completions produced by ASTUnit match those produced directly by code completion. Test case is forthcoming. llvm-svn: 112063
2010-08-26 02:03:13 +08:00
AllResults.push_back(Result(Completion, Priority, CursorKind,
Introduce new libclang API functions that determine the availability of a cursor or code-completion result, e.g., whether that result refers to an unavailable, deleted, or deprecated declaration. llvm-svn: 111858
2010-08-24 07:00:57 +08:00
C->Availability));
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
}
// If we did not add any cached completion results, just forward the
// results we were given to the next consumer.
if (!AddedResult) {
Next.ProcessCodeCompleteResults(S, Context, Results, NumResults);
return;
}
Move the sorting of code-completion results out of the main path and into the clients, e.g., the printing code-completion consumer and c-index-test. Clients may want to re-sort the results anyway. Provide a libclang function that sorts the results. 3rd try. How embarrassing. llvm-svn: 112180
2010-08-26 21:48:20 +08:00
Move some code out-of-line which has long since grown too large to be inlined. No functionality change. llvm-svn: 111176
2010-08-17 04:01:48 +08:00
Next.ProcessCodeCompleteResults(S, Context, AllResults.data(),
AllResults.size());
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
void ASTUnit::CodeComplete(StringRef File, unsigned Line, unsigned Column,
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
RemappedFile *RemappedFiles,
unsigned NumRemappedFiles,
Give clang_codeCompleteAt() an "options" parameter, and add a new flags enumeration + default-generating function that allows code-completion to be customized via the libclang API. Plus, turn on spell-checking when performing code completion. llvm-svn: 110319
2010-08-05 17:09:23 +08:00
bool IncludeMacros,
bool IncludeCodePatterns,
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
CodeCompleteConsumer &Consumer,
Rename Diagnostic to DiagnosticsEngine as per issue 5397 llvm-svn: 140478
2011-09-26 07:23:43 +08:00
DiagnosticsEngine &Diag, LangOptions &LangOpts,
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
SourceManager &SourceMgr, FileManager &FileMgr,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVectorImpl<StoredDiagnostic> &StoredDiagnostics,
SmallVectorImpl<const llvm::MemoryBuffer *> &OwnedBuffers) {
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
if (!Invocation)
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
return;
Simplify ASTUnit's internal timers, by not trying to keep a pile of timers to be dumped whenever the ASTUnit is destroyed. Instead, just print the time elapsed for each operation after we perform the operation. llvm-svn: 117550
2010-10-28 23:44:59 +08:00
SimpleTimer CompletionTimer(WantTiming);
Simplify code. llvm-svn: 118619
2010-11-10 04:00:56 +08:00
CompletionTimer.setOutput("Code completion @ " + File + ":" +
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
Twine(Line) + ":" + Twine(Column));
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
llvm::IntrusiveRefCntPtr<CompilerInvocation>
CCInvocation(new CompilerInvocation(*Invocation));
FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
PreprocessorOptions &PreprocessorOpts = CCInvocation->getPreprocessorOpts();
Give clang_codeCompleteAt() an "options" parameter, and add a new flags enumeration + default-generating function that allows code-completion to be customized via the libclang API. Plus, turn on spell-checking when performing code completion. llvm-svn: 110319
2010-08-05 17:09:23 +08:00
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
FrontendOpts.ShowMacrosInCodeCompletion
= IncludeMacros && CachedCompletionResults.empty();
Give clang_codeCompleteAt() an "options" parameter, and add a new flags enumeration + default-generating function that allows code-completion to be customized via the libclang API. Plus, turn on spell-checking when performing code completion. llvm-svn: 110319
2010-08-05 17:09:23 +08:00
FrontendOpts.ShowCodePatternsInCodeCompletion = IncludeCodePatterns;
Extend the code-completion caching infrastructure to include global declarations (in addition to macros). Each kind of declaration maps to a certain set of completion contexts, and the ASTUnit completion logic introduces the completion strings for those declarations if the actual code-completion occurs in one of the contexts where it matters. There are a few new code-completion-context kinds. Without these, certain completions (e.g., after "using namespace") would need to suppress all global completions, which would be unfortunate. Note that we don't get the priorities right for global completions, because we don't have enough type information. We'll need a way to compare types in an ASTContext-agnostic way before this can be implemented. llvm-svn: 111093
2010-08-15 14:18:01 +08:00
FrontendOpts.ShowGlobalSymbolsInCodeCompletion
= CachedCompletionResults.empty();
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
FrontendOpts.CodeCompletionAt.FileName = File;
FrontendOpts.CodeCompletionAt.Line = Line;
FrontendOpts.CodeCompletionAt.Column = Column;
// Set the language options appropriately.
Make 'LangOptions' in CompilerInvocation a heap-allocated, reference counted object. I discovered that llvm::RefCountedBase<T> has a bug where the reference count is copied in the copy constructor, which means that there were cases when the CompilerInvocation objects created by ASTUnit were actually leaked. When I fixed that bug locally, it showed that a whole bunch of code assumed that the LangOptions object that was part of CompilerInvocation was still alive. By making it heap-allocated and reference counted, we can keep it around after the CompilerInvocation object goes away. As part of this change, change CompilerInvocation:getLangOptions() to return a pointer, acting as another clue that this object may outlive the CompilerInvocation object. This commit doesn't fix the CompilerInvocation leak itself. That will come when I commit the fix to llvm::RefCountedBase<T> to mainline LLVM. llvm-svn: 144930
2011-11-18 07:01:24 +08:00
LangOpts = *CCInvocation->getLangOpts();
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
llvm::OwningPtr<CompilerInstance> Clang(new CompilerInstance());
// Recover resources if we crash before exiting this method.
Rework crash recovery cleanup in ASTUnit and CIndex to recover more memory during a Sema crash (we have just a handful of leaks left) and to use the simplified cleanup registration API. llvm-svn: 128059
2011-03-22 09:15:24 +08:00
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get());
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Clang->setInvocation(&*CCInvocation);
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].second;
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
// Set up diagnostics, capturing any diagnostics produced.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setDiagnostics(&Diag);
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts());
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
CaptureDroppedDiagnostics Capture(true,
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getDiagnostics(),
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
StoredDiagnostics);
// Create the target instance.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTargetOpts().Features = TargetFeatures;
Clang->setTarget(TargetInfo::CreateTargetInfo(Clang->getDiagnostics(),
Clang->getTargetOpts()));
if (!Clang->hasTarget()) {
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
Clang->setInvocation(0);
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
return;
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
}
// Inform the target of the language options.
//
// FIXME: We shouldn't need to do this, the target should be immutable once
// created. This complexity should be lifted elsewhere.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->getTarget().setForcedLangOptions(Clang->getLangOpts());
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs.size() == 1 &&
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
"Invocation must have exactly one source file!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_AST &&
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
"FIXME: AST inputs not yet supported here!");
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
assert(Clang->getFrontendOpts().Inputs[0].first != IK_LLVM_IR &&
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
"IR inputs not support here!");
// Use the source and file managers that we were given.
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setFileManager(&FileMgr);
Clang->setSourceManager(&SourceMgr);
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
// Remap files.
PreprocessorOpts.clearRemappedFiles();
When performing in-process code completion, don't free the remapped file buffers until the code completion results are destroyed; diagnostics may end up referring into the source. llvm-svn: 110216
2010-08-05 01:07:00 +08:00
PreprocessorOpts.RetainRemappedFileBuffers = true;
When performing code-completion in the presence of a preamble, make sure to (1) actually use the remapped files we were given rather than old data, and (2) keep the remapped files alive until the code-completion results are destroyed. Big thanks to Daniel for the test case. llvm-svn: 111597
2010-08-20 08:59:43 +08:00
for (unsigned I = 0; I != NumRemappedFiles; ++I) {
Currently we can only remap a file by creating a MemoryBuffer and replacing the file contents with it. Allow remapping a file by specifying another filename whose contents should be loaded if the original file gets loaded. This allows to override files without having to create & load buffers in advance. llvm-svn: 127052
2011-03-05 09:03:53 +08:00
FilenameOrMemBuf fileOrBuf = RemappedFiles[I].second;
if (const llvm::MemoryBuffer *
memBuf = fileOrBuf.dyn_cast<const llvm::MemoryBuffer *>()) {
PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, memBuf);
OwnedBuffers.push_back(memBuf);
} else {
const char *fname = fileOrBuf.get<const char *>();
PreprocessorOpts.addRemappedFile(RemappedFiles[I].first, fname);
}
When performing code-completion in the presence of a preamble, make sure to (1) actually use the remapped files we were given rather than old data, and (2) keep the remapped files alive until the code-completion results are destroyed. Big thanks to Daniel for the test case. llvm-svn: 111597
2010-08-20 08:59:43 +08:00
}
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Implement caching of code-completion results for macro definitions when the CXTranslationUnit_CacheCompletionResults option is given to clang_parseTranslationUnit(). Essentially, we compute code-completion results for macro definitions after we have parsed the file, then store an ASTContext-agnostic version of those results (completion string, cursor kind, priority, and active contexts) in the ASTUnit. When performing code completion in that ASTUnit, we splice the macro definition results into the results provided by the actual code-completion (which has had macros turned off) before libclang gets those results. We use completion context information to only splice in those results that make sense for that context. With a completion involving all of the macros from Cocoa.h and a few other system libraries (totally ~8500 macro definitions) living in a precompiled header, we get about a 9% performance improvement from code completion, since we no longer have to deserialize all of the macro definitions from the precompiled header. Note that macro definitions are merely the canary; the cache is designed to also support other top-level declarations, which should be a bigger performance win. That optimization will be next. Note also that there is no mechanism for determining when to throw away the cache and recompute its contents. llvm-svn: 111051
2010-08-14 06:48:40 +08:00
// Use the code completion consumer we were given, but adding any cached
// code-completion results.
When performing code completion within ASTUnit, allocate the AugmentedCodeCompleteConsumer on the heap, so it's always cleaned up properly llvm-svn: 120290
2010-11-30 00:13:56 +08:00
AugmentedCodeCompleteConsumer *AugmentedConsumer
= new AugmentedCodeCompleteConsumer(*this, Consumer,
FrontendOpts.ShowMacrosInCodeCompletion,
FrontendOpts.ShowCodePatternsInCodeCompletion,
FrontendOpts.ShowGlobalSymbolsInCodeCompletion);
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
Clang->setCodeCompletionConsumer(AugmentedConsumer);
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
// If we have a precompiled preamble, try to use it. We only allow
// the use of the precompiled preamble if we're if the completion
// point is within the main file, after the end of the precompiled
// preamble.
llvm::MemoryBuffer *OverrideMainBuffer = 0;
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
if (!getPreambleFile(this).empty()) {
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
using llvm::sys::FileStatus;
llvm::sys::PathWithStatus CompleteFilePath(File);
llvm::sys::PathWithStatus MainPath(OriginalSourceFile);
if (const FileStatus *CompleteFileStatus = CompleteFilePath.getFileStatus())
if (const FileStatus *MainStatus = MainPath.getFileStatus())
Fix Lexer::ComputePreamble when MaxLines parameter is non-zero. The function was only counting lines that included tokens and not empty lines, but MaxLines (mainly initiated to the line where the code-completion point resides) is a count of overall lines (even empty ones). llvm-svn: 139085
2011-09-04 11:32:04 +08:00
if (CompleteFileStatus->getUniqueID() == MainStatus->getUniqueID() &&
Line > 1)
When performing code-completion in the presence of a preamble, make sure to (1) actually use the remapped files we were given rather than old data, and (2) keep the remapped files alive until the code-completion results are destroyed. Big thanks to Daniel for the test case. llvm-svn: 111597
2010-08-20 08:59:43 +08:00
OverrideMainBuffer
Improve crash recovery cleanup to recovery CompilerInstances during crash recovery. This was a huge resource "root" during crashes. This change requires making a bunch of fundamental Clang structures (optionally) reference counted to allow correct ownership semantics of these objects (e.g., ASTContext) to play out between an active ASTUnit and CompilerInstance object. llvm-svn: 128011
2011-03-22 02:40:17 +08:00
= getMainBufferWithPrecompiledPreamble(*CCInvocation, false,
Fix an off-by-one error when computing the precompiled preamble for code completion. We were allowing the preamble to include the line that we're code-completing on. Again, testcase is forthcoming. llvm-svn: 112064
2010-08-26 02:04:15 +08:00
Line - 1);
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
}
// If the main file has been overridden due to the use of a preamble,
// make that override happen and introduce the preamble.
Improve our uniquing of file entries when files are re-saved or are overridden via remapping. Thus, when we create a "virtual" file in the file manager, we still stat() the real file that lives behind it so that we can provide proper uniquing based on inodes. This helps keep the file manager much more consistent. To take advantage of this when reparsing files in libclang, we disable the use of the stat() cache when reparsing or performing code completion, since the stat() cache is very likely to be out of date in this use case. llvm-svn: 124971
2011-02-06 03:42:43 +08:00
PreprocessorOpts.DisableStatCache = true;
When we load an ASTUnit from command-line arguments, hold on to the diagnostics produced by the driver itself. Previously, we were allowing these to either be dropped or to slip through to stderr. Fixes <rdar://problem/7595339>. llvm-svn: 116285
2010-10-12 08:50:20 +08:00
StoredDiagnostics.insert(StoredDiagnostics.end(),
[libclang] Make sure we don't try to erase past the StoredDiagnostics vector. Ted came upon the bug but I couldn't make a test out of it. llvm-svn: 142805
2011-10-25 01:25:20 +08:00
stored_diag_begin(),
stored_diag_afterDriver_begin());
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
if (OverrideMainBuffer) {
PreprocessorOpts.addRemappedFile(OriginalSourceFile, OverrideMainBuffer);
PreprocessorOpts.PrecompiledPreambleBytes.first = Preamble.size();
PreprocessorOpts.PrecompiledPreambleBytes.second
= PreambleEndsAtStartOfLine;
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
PreprocessorOpts.ImplicitPCHInclude = getPreambleFile(this);
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
PreprocessorOpts.DisablePCHValidation = true;
When performing code-completion in the presence of a preamble, make sure to (1) actually use the remapped files we were given rather than old data, and (2) keep the remapped files alive until the code-completion results are destroyed. Big thanks to Daniel for the test case. llvm-svn: 111597
2010-08-20 08:59:43 +08:00
OwnedBuffers.push_back(OverrideMainBuffer);
When we decide not to reuse a precompiled preamble, clear out the previous precompiled preamble completely. Fixes <rdar://problem/8330950>. llvm-svn: 111590
2010-08-20 08:02:33 +08:00
} else {
PreprocessorOpts.PrecompiledPreambleBytes.first = 0;
PreprocessorOpts.PrecompiledPreambleBytes.second = false;
Use precompiled preambles for in-process code completion. llvm-svn: 110596
2010-08-10 04:45:32 +08:00
}
Introduce a new libclang parsing flag, CXTranslationUnit_NestedMacroInstantiations, which indicates whether we want to see "nested" macro instantiations (e.g., those that occur inside other macro instantiations) within the detailed preprocessing record. Many clients (e.g., those that only care about visible tokens) don't care about this information, and in code that uses preprocessor metaprogramming, this information can have a very high cost. Addresses <rdar://problem/9389320>. llvm-svn: 130990
2011-05-07 00:33:08 +08:00
// Disable the preprocessing record
PreprocessorOpts.DetailedRecord = false;
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
llvm::OwningPtr<SyntaxOnlyAction> Act;
Act.reset(new SyntaxOnlyAction);
Use CrashRecoveryContextCleanup objects to reclaim resources from CompilerInstance objects. llvm-svn: 128009
2011-03-22 02:40:07 +08:00
if (Act->BeginSourceFile(*Clang.get(), Clang->getFrontendOpts().Inputs[0].second,
Clang->getFrontendOpts().Inputs[0].first)) {
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
if (OverrideMainBuffer) {
Move ASTUnit's handling of temporary files and the preamble file into a lazily-created static DenseMap. This DenseMap is cleared (and the files erased) via an atexit routine in the case an ASTUnit is not destroyed. Fixes <rdar://problem/10293367>. llvm-svn: 143115
2011-10-28 01:55:18 +08:00
std::string ModName = getPreambleFile(this);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
TranslateStoredDiagnostics(Clang->getModuleManager(), ModName,
getSourceManager(), PreambleDiagnostics,
StoredDiagnostics);
}
Add code-completion support directly to ASTUnit, which performs code completion within the translation unit using the same command-line arguments for parsing the translation unit. Eventually, we'll reuse the precompiled preamble to improve code-completion performance, and this also gives us a place to cache results. Expose this function via the new libclang function clang_codeCompleteAt(), which performs the code completion within a CXTranslationUnit. The completion occurs in-process (clang_codeCompletion() runs code completion out-of-process). llvm-svn: 110210
2010-08-05 00:47:14 +08:00
Act->Execute();
Act->EndSourceFile();
}
}
Implement clang_saveTranslationUnit(), which saves a translation unit into a PCH/AST file. llvm-svn: 111006
2010-08-13 13:36:37 +08:00
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
CXSaveError ASTUnit::Save(StringRef File) {
Keep track of when "unrecoverable" errors occur, then allow clang_saveTranslationUnit() to save a PCH file if the only errors it contains are recoverable errors. Fixes <rdar://problem/9727804>. llvm-svn: 134503
2011-07-07 01:40:26 +08:00
if (getDiagnostics().hasUnrecoverableErrorOccurred())
libclang: Allow callers of clang_saveTranslationUnit() to distinguish between different classes of errors. Addresses most of <rdar://problem/9660328>. llvm-svn: 134495
2011-07-07 00:43:36 +08:00
return CXSaveError_TranslationErrors;
For ASTUnit::Save, write the AST to a temporary and then rename it to the actual filename. Should avoid race conditions. Addresses rdar://9788943. llvm-svn: 135691
2011-07-22 02:44:49 +08:00
// Write to a temporary file and later rename it to the actual file, to avoid
// possible race conditions.
Cut down the number of open/close system calls for output files. For PCH files, have only one open/close for temporary + rename to be safe from race conditions. For all other output files open/close the output file directly. Depends on llvm r136310. rdar://9082880 & http://llvm.org/PR9374. llvm-svn: 136315
2011-07-28 08:45:10 +08:00
llvm::SmallString<128> TempPath;
TempPath = File;
TempPath += "-%%%%%%%%";
int fd;
if (llvm::sys::fs::unique_file(TempPath.str(), fd, TempPath,
/*makeAbsolute=*/false))
For ASTUnit::Save, write the AST to a temporary and then rename it to the actual filename. Should avoid race conditions. Addresses rdar://9788943. llvm-svn: 135691
2011-07-22 02:44:49 +08:00
return CXSaveError_Unknown;
Implement clang_saveTranslationUnit(), which saves a translation unit into a PCH/AST file. llvm-svn: 111006
2010-08-13 13:36:37 +08:00
// FIXME: Can we somehow regenerate the stat cache here, or do we need to
// unconditionally create a stat cache when we parse the file?
Cut down the number of open/close system calls for output files. For PCH files, have only one open/close for temporary + rename to be safe from race conditions. For all other output files open/close the output file directly. Depends on llvm r136310. rdar://9082880 & http://llvm.org/PR9374. llvm-svn: 136315
2011-07-28 08:45:10 +08:00
llvm::raw_fd_ostream Out(fd, /*shouldClose=*/true);
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
serialize(Out);
Out.close();
For ASTUnit::Save, write the AST to a temporary and then rename it to the actual filename. Should avoid race conditions. Addresses rdar://9788943. llvm-svn: 135691
2011-07-22 02:44:49 +08:00
if (Out.has_error())
return CXSaveError_Unknown;
if (llvm::error_code ec = llvm::sys::fs::rename(TempPath.str(), File)) {
bool exists;
llvm::sys::fs::remove(TempPath.str(), exists);
return CXSaveError_Unknown;
}
return CXSaveError_None;
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
bool ASTUnit::serialize(raw_ostream &OS) {
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
if (getDiagnostics().hasErrorOccurred())
return true;
Implement clang_saveTranslationUnit(), which saves a translation unit into a PCH/AST file. llvm-svn: 111006
2010-08-13 13:36:37 +08:00
std::vector<unsigned char> Buffer;
llvm::BitstreamWriter Stream(Buffer);
Rename PCHWriter to ASTWriter llvm-svn: 111463
2010-08-19 07:56:21 +08:00
ASTWriter Writer(Stream);
Modules hide macro definitions by default, so that silly things like include guards don't show up as macro definitions in every translation unit that imports a module. Macro definitions can, however, be exported with the intentionally-ugly #__export_macro__ directive. Implement this feature by not even bothering to serialize non-exported macros to a module, because clients of that module need not (should not) know that these macros even exist. llvm-svn: 138943
2011-09-02 01:04:32 +08:00
// FIXME: Handle modules
Writer.WriteAST(getSema(), 0, std::string(), /*IsModule=*/false, "");
Implement clang_saveTranslationUnit(), which saves a translation unit into a PCH/AST file. llvm-svn: 111006
2010-08-13 13:36:37 +08:00
// Write the generated bitstream to "Out".
Simplify the ownership model for DiagnosticClients, which was really convoluted and a bit leaky. Now, the Diagnostic object owns its DiagnosticClient. llvm-svn: 111437
2010-08-19 06:29:43 +08:00
if (!Buffer.empty())
Introduce '-chain-include' option to specify headers that will be converted to chained PCHs in memory without having to use multiple runs and intermediate files. Intended for testing & debugging of chained PCH. llvm-svn: 127339
2011-03-10 01:21:42 +08:00
OS.write((char *)&Buffer.front(), Buffer.size());
return false;
Implement clang_saveTranslationUnit(), which saves a translation unit into a PCH/AST file. llvm-svn: 111006
2010-08-13 13:36:37 +08:00
}
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
typedef ContinuousRangeMap<unsigned, int, 2> SLocRemap;
static void TranslateSLoc(SourceLocation &L, SLocRemap &Remap) {
unsigned Raw = L.getRawEncoding();
const unsigned MacroBit = 1U << 31;
L = SourceLocation::getFromRawEncoding((Raw & MacroBit) |
((Raw & ~MacroBit) + Remap.find(Raw & ~MacroBit)->second));
}
void ASTUnit::TranslateStoredDiagnostics(
ASTReader *MMan,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
StringRef ModName,
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
SourceManager &SrcMgr,
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
const SmallVectorImpl<StoredDiagnostic> &Diags,
SmallVectorImpl<StoredDiagnostic> &Out) {
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
// The stored diagnostic has the old source manager in it; update
// the locations to refer into the new source manager. We also need to remap
// all the locations to the new view. This includes the diag location, any
// associated source ranges, and the source ranges of associated fix-its.
// FIXME: There should be a cleaner way to do this.
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<StoredDiagnostic, 4> Result;
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Result.reserve(Diags.size());
assert(MMan && "Don't have a module manager");
This patch extends the previous patch by starting to incorporate more functionality, like lookup-by-name and exporting lookup tables, into the module manager. Methods now have documentation. A few more functions have been switched over to the new iterator style and away from manual/explicit iteration. Ultimately we want to move away from name lookup here, as symlinks make filenames not a safe unique value, but we use it here as a stopgap before better measures are in place (namely instead using FileEntry* from a global FileManager). llvm-svn: 136107
2011-07-27 02:21:30 +08:00
serialization::Module *Mod = MMan->ModuleMgr.lookup(ModName);
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
assert(Mod && "Don't have preamble module");
SLocRemap &Remap = Mod->SLocRemap;
for (unsigned I = 0, N = Diags.size(); I != N; ++I) {
// Rebuild the StoredDiagnostic.
const StoredDiagnostic &SD = Diags[I];
SourceLocation L = SD.getLocation();
TranslateSLoc(L, Remap);
FullSourceLoc Loc(L, SrcMgr);
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<CharSourceRange, 4> Ranges;
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
Ranges.reserve(SD.range_size());
for (StoredDiagnostic::range_iterator I = SD.range_begin(),
E = SD.range_end();
I != E; ++I) {
SourceLocation BL = I->getBegin();
TranslateSLoc(BL, Remap);
SourceLocation EL = I->getEnd();
TranslateSLoc(EL, Remap);
Ranges.push_back(CharSourceRange(SourceRange(BL, EL), I->isTokenRange()));
}
remove unneeded llvm:: namespace qualifiers on some core types now that LLVM.h imports them into the clang namespace. llvm-svn: 135852
2011-07-23 18:55:15 +08:00
SmallVector<FixItHint, 2> FixIts;
Revamp the SourceManager to separate the representation of parsed source locations from source locations loaded from an AST/PCH file. Previously, loading an AST/PCH file involved carefully pre-allocating space at the beginning of the source manager for the source locations and FileIDs that correspond to the prefix, and then appending the source locations/FileIDs used for parsing the remaining translation unit. This design forced us into loading PCH files early, as a prefix, whic has become a rather significant limitation. This patch splits the SourceManager space into two parts: for source location "addresses", the lower values (growing upward) are used to describe parsed code, while upper values (growing downward) are used for source locations loaded from AST/PCH files. Similarly, positive FileIDs are used to describe parsed code while negative FileIDs are used to file/macro locations loaded from AST/PCH files. As a result, we can load PCH/AST files even during parsing, making various improvemnts in the future possible, e.g., teaching #include <foo.h> to look for and load <foo.h.gch> if it happens to be already available. This patch was originally written by Sebastian Redl, then brought forward to the modern age by Jonathan Turner, and finally polished/finished by me to be committed. llvm-svn: 135484
2011-07-20 00:10:42 +08:00
FixIts.reserve(SD.fixit_size());
for (StoredDiagnostic::fixit_iterator I = SD.fixit_begin(),
E = SD.fixit_end();
I != E; ++I) {
FixIts.push_back(FixItHint());
FixItHint &FH = FixIts.back();
FH.CodeToInsert = I->CodeToInsert;
SourceLocation BL = I->RemoveRange.getBegin();
TranslateSLoc(BL, Remap);
SourceLocation EL = I->RemoveRange.getEnd();
TranslateSLoc(EL, Remap);
FH.RemoveRange = CharSourceRange(SourceRange(BL, EL),
I->RemoveRange.isTokenRange());
}
Result.push_back(StoredDiagnostic(SD.getLevel(), SD.getID(),
SD.getMessage(), Loc, Ranges, FixIts));
}
Result.swap(Out);
}
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
static inline bool compLocDecl(std::pair<unsigned, Decl *> L,
std::pair<unsigned, Decl *> R) {
return L.first < R.first;
}
void ASTUnit::addFileLevelDecl(Decl *D) {
assert(D);
ASTConsumer::handleTopLevelDecl will end up getting called for function template instantiations. Fixes <rdar://problem/10398005> / PR11312. llvm-svn: 143984
2011-11-08 02:53:57 +08:00
// We only care about local declarations.
if (D->isFromASTFile())
return;
Have the ASTUnit associate the local declarations that get parsed with the file that contains them. llvm-svn: 143338
2011-10-31 15:19:59 +08:00
SourceManager &SM = *SourceMgr;
SourceLocation Loc = D->getLocation();
if (Loc.isInvalid() || !SM.isLocalSourceLocation(Loc))
return;
// We only keep track of the file-level declarations of each file.
if (!D->getLexicalDeclContext()->isFileContext())
return;
SourceLocation FileLoc = SM.getFileLoc(Loc);
assert(SM.isLocalSourceLocation(FileLoc));
FileID FID;
unsigned Offset;
llvm::tie(FID, Offset) = SM.getDecomposedLoc(FileLoc);
if (FID.isInvalid())
return;
LocDeclsTy *&Decls = FileDecls[FID];
if (!Decls)
Decls = new LocDeclsTy();
std::pair<unsigned, Decl *> LocDecl(Offset, D);
if (Decls->empty() || Decls->back().first <= Offset) {
Decls->push_back(LocDecl);
return;
}
LocDeclsTy::iterator
I = std::upper_bound(Decls->begin(), Decls->end(), LocDecl, compLocDecl);
Decls->insert(I, LocDecl);
}
[libclang] Add infrastructure to be able to only deserialize decls in a file region and use it for clang_getCursor. llvm-svn: 143605
2011-11-03 10:20:32 +08:00
void ASTUnit::findFileRegionDecls(FileID File, unsigned Offset, unsigned Length,
SmallVectorImpl<Decl *> &Decls) {
if (File.isInvalid())
return;
if (SourceMgr->isLoadedFileID(File)) {
assert(Ctx->getExternalSource() && "No external source!");
return Ctx->getExternalSource()->FindFileRegionDecls(File, Offset, Length,
Decls);
}
FileDeclsTy::iterator I = FileDecls.find(File);
if (I == FileDecls.end())
return;
LocDeclsTy &LocDecls = *I->second;
if (LocDecls.empty())
return;
LocDeclsTy::iterator
BeginIt = std::lower_bound(LocDecls.begin(), LocDecls.end(),
std::make_pair(Offset, (Decl*)0), compLocDecl);
if (BeginIt != LocDecls.begin())
--BeginIt;
[libclang] Fix operations (token annotation, getting cursor, etc.) with a file region inside an objc container that "contains" other file-level declarations. When getting the array of file-level declarations that overlap with a file region, we failed to report that the region overlaps with an objc container, if the container had other file-level declarations declared lexically inside it. Fix this by marking such declarations as "isTopLevelDeclInObjCContainer" in the AST and handling them appropriately. llvm-svn: 145109
2011-11-24 04:27:36 +08:00
// If we are pointing at a top-level decl inside an objc container, we need
// to backtrack until we find it otherwise we will fail to report that the
// region overlaps with an objc container.
while (BeginIt != LocDecls.begin() &&
BeginIt->second->isTopLevelDeclInObjCContainer())
--BeginIt;
[libclang] Add infrastructure to be able to only deserialize decls in a file region and use it for clang_getCursor. llvm-svn: 143605
2011-11-03 10:20:32 +08:00
LocDeclsTy::iterator
EndIt = std::upper_bound(LocDecls.begin(), LocDecls.end(),
std::make_pair(Offset+Length, (Decl*)0),
compLocDecl);
if (EndIt != LocDecls.end())
++EndIt;
for (LocDeclsTy::iterator DIt = BeginIt; DIt != EndIt; ++DIt)
Decls.push_back(DIt->second);
}
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
SourceLocation ASTUnit::getLocation(const FileEntry *File,
unsigned Line, unsigned Col) const {
const SourceManager &SM = getSourceManager();
Don't map a file:line:col triplet that is inside the preamble range to a "loaded" location of the precompiled preamble. Instead, handle specially locations of preprocessed entities: -When looking up for preprocessed entities, map main file locations inside the preamble range to a preamble loaded location. -When getting the source range of a preprocessing cursor, map preamble loaded locations back to main file locations. Fixes rdar://10175093 & http://llvm.org/PR10999 llvm-svn: 140519
2011-09-26 16:01:41 +08:00
SourceLocation Loc = SM.translateFileLineCol(File, Line, Col);
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
return SM.getMacroArgExpandedLocation(Loc);
}
SourceLocation ASTUnit::getLocation(const FileEntry *File,
unsigned Offset) const {
const SourceManager &SM = getSourceManager();
Don't map a file:line:col triplet that is inside the preamble range to a "loaded" location of the precompiled preamble. Instead, handle specially locations of preprocessed entities: -When looking up for preprocessed entities, map main file locations inside the preamble range to a preamble loaded location. -When getting the source range of a preprocessing cursor, map preamble loaded locations back to main file locations. Fixes rdar://10175093 & http://llvm.org/PR10999 llvm-svn: 140519
2011-09-26 16:01:41 +08:00
SourceLocation FileLoc = SM.translateFileLineCol(File, 1, 1);
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
return SM.getMacroArgExpandedLocation(FileLoc.getLocWithOffset(Offset));
}
Don't map a file:line:col triplet that is inside the preamble range to a "loaded" location of the precompiled preamble. Instead, handle specially locations of preprocessed entities: -When looking up for preprocessed entities, map main file locations inside the preamble range to a preamble loaded location. -When getting the source range of a preprocessing cursor, map preamble loaded locations back to main file locations. Fixes rdar://10175093 & http://llvm.org/PR10999 llvm-svn: 140519
2011-09-26 16:01:41 +08:00
/// \brief If \arg Loc is a loaded location from the preamble, returns
/// the corresponding local location of the main file, otherwise it returns
/// \arg Loc.
SourceLocation ASTUnit::mapLocationFromPreamble(SourceLocation Loc) {
FileID PreambleID;
if (SourceMgr)
PreambleID = SourceMgr->getPreambleFileID();
if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid())
return Loc;
unsigned Offs;
if (SourceMgr->isInFileID(Loc, PreambleID, &Offs) && Offs < Preamble.size()) {
SourceLocation FileLoc
= SourceMgr->getLocForStartOfFile(SourceMgr->getMainFileID());
return FileLoc.getLocWithOffset(Offs);
}
return Loc;
}
/// \brief If \arg Loc is a local location of the main file but inside the
/// preamble chunk, returns the corresponding loaded location from the
/// preamble, otherwise it returns \arg Loc.
SourceLocation ASTUnit::mapLocationToPreamble(SourceLocation Loc) {
FileID PreambleID;
if (SourceMgr)
PreambleID = SourceMgr->getPreambleFileID();
if (Loc.isInvalid() || Preamble.empty() || PreambleID.isInvalid())
return Loc;
unsigned Offs;
if (SourceMgr->isInFileID(Loc, SourceMgr->getMainFileID(), &Offs) &&
Offs < Preamble.size()) {
SourceLocation FileLoc = SourceMgr->getLocForStartOfFile(PreambleID);
return FileLoc.getLocWithOffset(Offs);
}
return Loc;
}
[PCH] When visiting preprocessed entities, make it possible to avoid deserializing preprocessed entities that are #included in the range that we are interested. This is useful when we are interested in preprocessed entities of a specific file, e.g when we are annotating tokens. There is also an optimization where we cache the last result of PreprocessingRecord::getPreprocessedEntitiesInRange and we re-use it if there is a call with the same range as before. rdar://10313365 llvm-svn: 142887
2011-10-25 08:29:50 +08:00
bool ASTUnit::isInPreambleFileID(SourceLocation Loc) {
FileID FID;
if (SourceMgr)
FID = SourceMgr->getPreambleFileID();
if (Loc.isInvalid() || FID.isInvalid())
return false;
return SourceMgr->isInFileID(Loc, FID);
}
bool ASTUnit::isInMainFileID(SourceLocation Loc) {
FileID FID;
if (SourceMgr)
FID = SourceMgr->getMainFileID();
if (Loc.isInvalid() || FID.isInvalid())
return false;
return SourceMgr->isInFileID(Loc, FID);
}
SourceLocation ASTUnit::getEndOfPreambleFileID() {
FileID FID;
if (SourceMgr)
FID = SourceMgr->getPreambleFileID();
if (FID.isInvalid())
return SourceLocation();
return SourceMgr->getLocForEndOfFile(FID);
}
SourceLocation ASTUnit::getStartOfMainFileID() {
FileID FID;
if (SourceMgr)
FID = SourceMgr->getMainFileID();
if (FID.isInvalid())
return SourceLocation();
return SourceMgr->getLocForStartOfFile(FID);
}
[libclang] When getting a source location from a file:line:col triplet check whether the requested location points inside the precompiled preamble, in which case the returned source location will be a "loaded" one. llvm-svn: 140060
2011-09-20 04:40:35 +08:00
void ASTUnit::PreambleData::countLines() const {
NumLines = 0;
if (empty())
return;
for (std::vector<char>::const_iterator
I = Buffer.begin(), E = Buffer.end(); I != E; ++I) {
if (*I == '\n')
++NumLines;
}
if (Buffer.back() != '\n')
++NumLines;
}
[libclang] Implement ConcurrencyCheck using a recursive mutex to allow re-entrancy in the same thread. The checks are performed only in DEBUG, it becomes no-op in release mode. llvm-svn: 141582
2011-10-11 05:57:12 +08:00
#ifndef NDEBUG
ASTUnit::ConcurrencyState::ConcurrencyState() {
Mutex = new llvm::sys::MutexImpl(/*recursive=*/true);
}
ASTUnit::ConcurrencyState::~ConcurrencyState() {
delete static_cast<llvm::sys::MutexImpl *>(Mutex);
}
void ASTUnit::ConcurrencyState::start() {
bool acquired = static_cast<llvm::sys::MutexImpl *>(Mutex)->tryacquire();
assert(acquired && "Concurrent access to ASTUnit!");
}
void ASTUnit::ConcurrencyState::finish() {
static_cast<llvm::sys::MutexImpl *>(Mutex)->release();
}
#else // NDEBUG
ASTUnit::ConcurrencyState::ConcurrencyState() {}
ASTUnit::ConcurrencyState::~ConcurrencyState() {}
void ASTUnit::ConcurrencyState::start() {}
void ASTUnit::ConcurrencyState::finish() {}
#endif