maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Revert "IntrusiveRefCntPtr -> std::shared_ptr for CompilerInvocationBase and CodeCompleteConsumer" 

Caused a memory leak reported by asan. Reverting while I investigate.

This reverts commit r291184.

llvm-svn: 291249
This commit is contained in:
David Blaikie 2017-01-06 17:47:10 +00:00
parent 3128d6b520
commit 81d0829438
24 changed files with 147 additions and 142 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
clang/include/clang/Frontend/ASTUnit.h
View File

@ -108,8 +108,8 @@ private:
/// Optional owned invocation, just used to make the invocation used in /// Optional owned invocation, just used to make the invocation used in
/// LoadFromCommandLine available. /// LoadFromCommandLine available.
std::shared_ptr<CompilerInvocation> Invocation; IntrusiveRefCntPtr<CompilerInvocation> Invocation;
// OnlyLocalDecls - when true, walking this AST should only visit declarations // OnlyLocalDecls - when true, walking this AST should only visit declarations
// that come from the AST itself, not from included precompiled headers. // that come from the AST itself, not from included precompiled headers.
// FIXME: This is temporary; eventually, CIndex will always do this. // FIXME: This is temporary; eventually, CIndex will always do this.
@ -358,21 +358,22 @@ public:
} }
/// \brief Retrieve the allocator used to cache global code completions. /// \brief Retrieve the allocator used to cache global code completions.
std::shared_ptr<GlobalCodeCompletionAllocator> IntrusiveRefCntPtr<GlobalCodeCompletionAllocator>
getCachedCompletionAllocator() { getCachedCompletionAllocator() {
return CachedCompletionAllocator; return CachedCompletionAllocator;
} }
CodeCompletionTUInfo &getCodeCompletionTUInfo() { CodeCompletionTUInfo &getCodeCompletionTUInfo() {
if (!CCTUInfo) if (!CCTUInfo)
CCTUInfo = llvm::make_unique<CodeCompletionTUInfo>( CCTUInfo.reset(new CodeCompletionTUInfo(
std::make_shared<GlobalCodeCompletionAllocator>()); new GlobalCodeCompletionAllocator));
return *CCTUInfo; return *CCTUInfo;
} }
private: private:
/// \brief Allocator used to store cached code completions. /// \brief Allocator used to store cached code completions.
std::shared_ptr<GlobalCodeCompletionAllocator> CachedCompletionAllocator; IntrusiveRefCntPtr<GlobalCodeCompletionAllocator>
CachedCompletionAllocator;
std::unique_ptr<CodeCompletionTUInfo> CCTUInfo; std::unique_ptr<CodeCompletionTUInfo> CCTUInfo;
@ -701,11 +702,11 @@ public:
/// remapped contents of that file. /// remapped contents of that file.
typedef std::pair<std::string, llvm::MemoryBuffer *> RemappedFile; typedef std::pair<std::string, llvm::MemoryBuffer *> RemappedFile;
/// \brief Create a ASTUnit. Gets ownership of the passed CompilerInvocation. /// \brief Create a ASTUnit. Gets ownership of the passed CompilerInvocation.
static std::unique_ptr<ASTUnit> static ASTUnit *create(CompilerInvocation *CI,
create(std::shared_ptr<CompilerInvocation> CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, bool CaptureDiagnostics, bool CaptureDiagnostics,
bool UserFilesAreVolatile); bool UserFilesAreVolatile);
/// \brief Create a ASTUnit from an AST file. /// \brief Create a ASTUnit from an AST file.
/// ///
@ -770,7 +771,7 @@ public:
/// created ASTUnit was passed in \p Unit then the caller can check that. /// created ASTUnit was passed in \p Unit then the caller can check that.
/// ///
static ASTUnit *LoadFromCompilerInvocationAction( static ASTUnit *LoadFromCompilerInvocationAction(
std::shared_ptr<CompilerInvocation> CI, CompilerInvocation *CI,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
FrontendAction *Action = nullptr, ASTUnit *Unit = nullptr, FrontendAction *Action = nullptr, ASTUnit *Unit = nullptr,
@ -797,7 +798,7 @@ public:
// FIXME: Move OnlyLocalDecls, UseBumpAllocator to setters on the ASTUnit, we // FIXME: Move OnlyLocalDecls, UseBumpAllocator to setters on the ASTUnit, we
// shouldn't need to specify them at construction time. // shouldn't need to specify them at construction time.
static std::unique_ptr<ASTUnit> LoadFromCompilerInvocation( static std::unique_ptr<ASTUnit> LoadFromCompilerInvocation(
std::shared_ptr<CompilerInvocation> CI, CompilerInvocation *CI,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr,
bool OnlyLocalDecls = false, bool CaptureDiagnostics = false, bool OnlyLocalDecls = false, bool CaptureDiagnostics = false,

4
clang/include/clang/Frontend/CompilerInstance.h
View File

@ -70,7 +70,7 @@ class TargetInfo;
/// and a long form that takes explicit instances of any required objects. /// and a long form that takes explicit instances of any required objects.
class CompilerInstance : public ModuleLoader { class CompilerInstance : public ModuleLoader {
/// The options used in this compiler instance. /// The options used in this compiler instance.
std::shared_ptr<CompilerInvocation> Invocation; IntrusiveRefCntPtr<CompilerInvocation> Invocation;
/// The diagnostics engine instance. /// The diagnostics engine instance.
IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics; IntrusiveRefCntPtr<DiagnosticsEngine> Diagnostics;
@ -228,7 +228,7 @@ public:
} }
/// setInvocation - Replace the current invocation. /// setInvocation - Replace the current invocation.
void setInvocation(std::shared_ptr<CompilerInvocation> Value); void setInvocation(CompilerInvocation *Value);
/// \brief Indicates whether we should (re)build the global module index. /// \brief Indicates whether we should (re)build the global module index.
bool shouldBuildGlobalModuleIndex() const; bool shouldBuildGlobalModuleIndex() const;

2
clang/include/clang/Frontend/CompilerInvocation.h
View File

@ -51,7 +51,7 @@ bool ParseDiagnosticArgs(DiagnosticOptions &Opts, llvm::opt::ArgList &Args,
bool DefaultDiagColor = true, bool DefaultDiagColor = true,
bool DefaultShowOpt = true); bool DefaultShowOpt = true);
class CompilerInvocationBase { class CompilerInvocationBase : public RefCountedBase<CompilerInvocation> {
void operator=(const CompilerInvocationBase &) = delete; void operator=(const CompilerInvocationBase &) = delete;
public: public:

6
clang/include/clang/Frontend/Utils.h
View File

@ -184,10 +184,10 @@ createChainedIncludesSource(CompilerInstance &CI,
/// ///
/// \return A CompilerInvocation, or 0 if none was built for the given /// \return A CompilerInvocation, or 0 if none was built for the given
/// argument vector. /// argument vector.
std::unique_ptr<CompilerInvocation> CompilerInvocation *
createInvocationFromCommandLine(ArrayRef<const char *> Args, createInvocationFromCommandLine(ArrayRef<const char *> Args,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags = IntrusiveRefCntPtr<DiagnosticsEngine> Diags =
IntrusiveRefCntPtr<DiagnosticsEngine>()); IntrusiveRefCntPtr<DiagnosticsEngine>());
/// Return the value of the last argument as an integer, or a default. If Diags /// Return the value of the last argument as an integer, or a default. If Diags
/// is non-null, emits an error if the argument is given, but non-integral. /// is non-null, emits an error if the argument is given, but non-integral.

17
clang/include/clang/Sema/CodeCompleteConsumer.h
View File

@ -509,18 +509,23 @@ public:
}; };
/// \brief Allocator for a cached set of global code completions. /// \brief Allocator for a cached set of global code completions.
class GlobalCodeCompletionAllocator : public CodeCompletionAllocator {}; class GlobalCodeCompletionAllocator
: public CodeCompletionAllocator,
public RefCountedBase<GlobalCodeCompletionAllocator>
{
};
class CodeCompletionTUInfo { class CodeCompletionTUInfo {
llvm::DenseMap<const DeclContext *, StringRef> ParentNames; llvm::DenseMap<const DeclContext *, StringRef> ParentNames;
std::shared_ptr<GlobalCodeCompletionAllocator> AllocatorRef; IntrusiveRefCntPtr<GlobalCodeCompletionAllocator> AllocatorRef;
public: public:
explicit CodeCompletionTUInfo( explicit CodeCompletionTUInfo(
std::shared_ptr<GlobalCodeCompletionAllocator> Allocator) IntrusiveRefCntPtr<GlobalCodeCompletionAllocator> Allocator)
: AllocatorRef(std::move(Allocator)) {} : AllocatorRef(std::move(Allocator)) {}
std::shared_ptr<GlobalCodeCompletionAllocator> getAllocatorRef() const { IntrusiveRefCntPtr<GlobalCodeCompletionAllocator> getAllocatorRef() const {
return AllocatorRef; return AllocatorRef;
} }
CodeCompletionAllocator &getAllocator() const { CodeCompletionAllocator &getAllocator() const {
@ -960,8 +965,8 @@ public:
/// results to the given raw output stream. /// results to the given raw output stream.
PrintingCodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts, PrintingCodeCompleteConsumer(const CodeCompleteOptions &CodeCompleteOpts,
raw_ostream &OS) raw_ostream &OS)
: CodeCompleteConsumer(CodeCompleteOpts, false), OS(OS), : CodeCompleteConsumer(CodeCompleteOpts, false), OS(OS),
CCTUInfo(std::make_shared<GlobalCodeCompletionAllocator>()) {} CCTUInfo(new GlobalCodeCompletionAllocator) {}
/// \brief Prints the finalized code-completion results. /// \brief Prints the finalized code-completion results.
void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context, void ProcessCodeCompleteResults(Sema &S, CodeCompletionContext Context,

8
clang/include/clang/Tooling/Tooling.h
View File

@ -69,8 +69,7 @@ public:
/// \brief Perform an action for an invocation. /// \brief Perform an action for an invocation.
virtual bool virtual bool
runInvocation(std::shared_ptr<clang::CompilerInvocation> Invocation, runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files,
FileManager *Files,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
DiagnosticConsumer *DiagConsumer) = 0; DiagnosticConsumer *DiagConsumer) = 0;
}; };
@ -86,8 +85,7 @@ public:
~FrontendActionFactory() override; ~FrontendActionFactory() override;
/// \brief Invokes the compiler with a FrontendAction created by create(). /// \brief Invokes the compiler with a FrontendAction created by create().
bool runInvocation(std::shared_ptr<clang::CompilerInvocation> Invocation, bool runInvocation(clang::CompilerInvocation *Invocation, FileManager *Files,
FileManager *Files,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
DiagnosticConsumer *DiagConsumer) override; DiagnosticConsumer *DiagConsumer) override;
@ -263,7 +261,7 @@ public:
bool runInvocation(const char *BinaryName, bool runInvocation(const char *BinaryName,
clang::driver::Compilation *Compilation, clang::driver::Compilation *Compilation,
std::shared_ptr<clang::CompilerInvocation> Invocation, clang::CompilerInvocation *Invocation,
std::shared_ptr<PCHContainerOperations> PCHContainerOps); std::shared_ptr<PCHContainerOperations> PCHContainerOps);
std::vector<std::string> CommandLine; std::vector<std::string> CommandLine;

4
clang/lib/ARCMigrate/ARCMT.cpp
View File

@ -271,7 +271,7 @@ bool arcmt::checkForManualIssues(
Diags->setClient(&errRec, /*ShouldOwnClient=*/false); Diags->setClient(&errRec, /*ShouldOwnClient=*/false);
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
std::move(CInvok), PCHContainerOps, Diags)); CInvok.release(), PCHContainerOps, Diags));
if (!Unit) { if (!Unit) {
errRec.FinishCapture(); errRec.FinishCapture();
return true; return true;
@ -547,7 +547,7 @@ bool MigrationProcess::applyTransform(TransformFn trans,
ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs)); ASTAction.reset(new ARCMTMacroTrackerAction(ARCMTMacroLocs));
std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction( std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
std::move(CInvok), PCHContainerOps, Diags, ASTAction.get())); CInvok.release(), PCHContainerOps, Diags, ASTAction.get()));
if (!Unit) { if (!Unit) {
errRec.FinishCapture(); errRec.FinishCapture();
return true; return true;

63
clang/lib/Frontend/ASTUnit.cpp
View File

@ -245,7 +245,7 @@ ASTUnit::~ASTUnit() {
// perform this operation here because we explicitly request that the // perform this operation here because we explicitly request that the
// compiler instance *not* free these buffers for each invocation of the // compiler instance *not* free these buffers for each invocation of the
// parser. // parser.
if (Invocation && OwnsRemappedFileBuffers) { if (Invocation.get() && OwnsRemappedFileBuffers) {
PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
for (const auto &RB : PPOpts.RemappedFileBuffers) for (const auto &RB : PPOpts.RemappedFileBuffers)
delete RB.second; delete RB.second;
@ -348,7 +348,7 @@ void ASTUnit::CacheCodeCompletionResults() {
// Gather the set of global code completions. // Gather the set of global code completions.
typedef CodeCompletionResult Result; typedef CodeCompletionResult Result;
SmallVector<Result, 8> Results; SmallVector<Result, 8> Results;
CachedCompletionAllocator = std::make_shared<GlobalCodeCompletionAllocator>(); CachedCompletionAllocator = new GlobalCodeCompletionAllocator;
CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator); CodeCompletionTUInfo CCTUInfo(CachedCompletionAllocator);
TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator, TheSema->GatherGlobalCodeCompletions(*CachedCompletionAllocator,
CCTUInfo, Results); CCTUInfo, Results);
@ -1048,7 +1048,10 @@ bool ASTUnit::Parse(std::shared_ptr<PCHContainerOperations> PCHContainerOps,
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get()); CICleanup(Clang.get());
Clang->setInvocation(std::make_shared<CompilerInvocation>(*Invocation)); IntrusiveRefCntPtr<CompilerInvocation>
CCInvocation(new CompilerInvocation(*Invocation));
Clang->setInvocation(CCInvocation.get());
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
// Set up diagnostics, capturing any diagnostics that would // Set up diagnostics, capturing any diagnostics that would
@ -1341,8 +1344,8 @@ ASTUnit::getMainBufferWithPrecompiledPreamble(
const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild, const CompilerInvocation &PreambleInvocationIn, bool AllowRebuild,
unsigned MaxLines) { unsigned MaxLines) {
auto PreambleInvocation = IntrusiveRefCntPtr<CompilerInvocation>
std::make_shared<CompilerInvocation>(PreambleInvocationIn); PreambleInvocation(new CompilerInvocation(PreambleInvocationIn));
FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts(); FrontendOptions &FrontendOpts = PreambleInvocation->getFrontendOpts();
PreprocessorOptions &PreprocessorOpts PreprocessorOptions &PreprocessorOpts
= PreambleInvocation->getPreprocessorOpts(); = PreambleInvocation->getPreprocessorOpts();
@ -1520,7 +1523,7 @@ ASTUnit::getMainBufferWithPrecompiledPreamble(
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get()); CICleanup(Clang.get());
Clang->setInvocation(std::move(PreambleInvocation)); Clang->setInvocation(&*PreambleInvocation);
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
// Set up diagnostics, capturing all of the diagnostics produced. // Set up diagnostics, capturing all of the diagnostics produced.
@ -1706,29 +1709,30 @@ StringRef ASTUnit::getASTFileName() const {
return Mod.FileName; return Mod.FileName;
} }
std::unique_ptr<ASTUnit> ASTUnit *ASTUnit::create(CompilerInvocation *CI,
ASTUnit::create(std::shared_ptr<CompilerInvocation> CI, IntrusiveRefCntPtr<DiagnosticsEngine> Diags,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, bool CaptureDiagnostics,
bool CaptureDiagnostics, bool UserFilesAreVolatile) { bool UserFilesAreVolatile) {
std::unique_ptr<ASTUnit> AST(new ASTUnit(false)); std::unique_ptr<ASTUnit> AST;
AST.reset(new ASTUnit(false));
ConfigureDiags(Diags, *AST, CaptureDiagnostics); ConfigureDiags(Diags, *AST, CaptureDiagnostics);
AST->Diagnostics = Diags;
AST->Invocation = CI;
AST->FileSystemOpts = CI->getFileSystemOpts();
IntrusiveRefCntPtr<vfs::FileSystem> VFS = IntrusiveRefCntPtr<vfs::FileSystem> VFS =
createVFSFromCompilerInvocation(*CI, *Diags); createVFSFromCompilerInvocation(*CI, *Diags);
if (!VFS) if (!VFS)
return nullptr; return nullptr;
AST->Diagnostics = Diags;
AST->FileSystemOpts = CI->getFileSystemOpts();
AST->Invocation = std::move(CI);
AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS); AST->FileMgr = new FileManager(AST->FileSystemOpts, VFS);
AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->UserFilesAreVolatile = UserFilesAreVolatile;
AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr, AST->SourceMgr = new SourceManager(AST->getDiagnostics(), *AST->FileMgr,
UserFilesAreVolatile); UserFilesAreVolatile);
return AST; return AST.release();
} }
ASTUnit *ASTUnit::LoadFromCompilerInvocationAction( ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
std::shared_ptr<CompilerInvocation> CI, CompilerInvocation *CI,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FrontendAction *Action, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FrontendAction *Action,
ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath, ASTUnit *Unit, bool Persistent, StringRef ResourceFilesPath,
@ -1742,7 +1746,7 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
ASTUnit *AST = Unit; ASTUnit *AST = Unit;
if (!AST) { if (!AST) {
// Create the AST unit. // Create the AST unit.
OwnAST = create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile); OwnAST.reset(create(CI, Diags, CaptureDiagnostics, UserFilesAreVolatile));
AST = OwnAST.get(); AST = OwnAST.get();
if (!AST) if (!AST)
return nullptr; return nullptr;
@ -1781,7 +1785,7 @@ ASTUnit *ASTUnit::LoadFromCompilerInvocationAction(
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get()); CICleanup(Clang.get());
Clang->setInvocation(std::move(CI)); Clang->setInvocation(CI);
AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); AST->OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
// Set up diagnostics, capturing any diagnostics that would // Set up diagnostics, capturing any diagnostics that would
@ -1899,7 +1903,7 @@ bool ASTUnit::LoadFromCompilerInvocation(
} }
std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation( std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
std::shared_ptr<CompilerInvocation> CI, CompilerInvocation *CI,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr, IntrusiveRefCntPtr<DiagnosticsEngine> Diags, FileManager *FileMgr,
bool OnlyLocalDecls, bool CaptureDiagnostics, bool OnlyLocalDecls, bool CaptureDiagnostics,
@ -1916,7 +1920,7 @@ std::unique_ptr<ASTUnit> ASTUnit::LoadFromCompilerInvocation(
AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults; AST->ShouldCacheCodeCompletionResults = CacheCodeCompletionResults;
AST->IncludeBriefCommentsInCodeCompletion AST->IncludeBriefCommentsInCodeCompletion
= IncludeBriefCommentsInCodeCompletion; = IncludeBriefCommentsInCodeCompletion;
AST->Invocation = std::move(CI); AST->Invocation = CI;
AST->FileSystemOpts = FileMgr->getFileSystemOpts(); AST->FileSystemOpts = FileMgr->getFileSystemOpts();
AST->FileMgr = FileMgr; AST->FileMgr = FileMgr;
AST->UserFilesAreVolatile = UserFilesAreVolatile; AST->UserFilesAreVolatile = UserFilesAreVolatile;
@ -1948,8 +1952,8 @@ ASTUnit *ASTUnit::LoadFromCommandLine(
assert(Diags.get() && "no DiagnosticsEngine was provided"); assert(Diags.get() && "no DiagnosticsEngine was provided");
SmallVector<StoredDiagnostic, 4> StoredDiagnostics; SmallVector<StoredDiagnostic, 4> StoredDiagnostics;
std::shared_ptr<CompilerInvocation> CI; IntrusiveRefCntPtr<CompilerInvocation> CI;
{ {
@ -1957,7 +1961,8 @@ ASTUnit *ASTUnit::LoadFromCommandLine(
StoredDiagnostics); StoredDiagnostics);
CI = clang::createInvocationFromCommandLine( CI = clang::createInvocationFromCommandLine(
llvm::makeArrayRef(ArgBegin, ArgEnd), Diags); llvm::makeArrayRef(ArgBegin, ArgEnd),
Diags);
if (!CI) if (!CI)
return nullptr; return nullptr;
} }
@ -2328,7 +2333,8 @@ void ASTUnit::CodeComplete(
CompletionTimer.setOutput("Code completion @ " + File + ":" + CompletionTimer.setOutput("Code completion @ " + File + ":" +
Twine(Line) + ":" + Twine(Column)); Twine(Line) + ":" + Twine(Column));
auto CCInvocation = std::make_shared<CompilerInvocation>(*Invocation); IntrusiveRefCntPtr<CompilerInvocation>
CCInvocation(new CompilerInvocation(*Invocation));
FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts(); FrontendOptions &FrontendOpts = CCInvocation->getFrontendOpts();
CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts; CodeCompleteOptions &CodeCompleteOpts = FrontendOpts.CodeCompleteOpts;
@ -2360,8 +2366,7 @@ void ASTUnit::CodeComplete(
llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance> llvm::CrashRecoveryContextCleanupRegistrar<CompilerInstance>
CICleanup(Clang.get()); CICleanup(Clang.get());
auto &Inv = *CCInvocation; Clang->setInvocation(&*CCInvocation);
Clang->setInvocation(std::move(CCInvocation));
OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile(); OriginalSourceFile = Clang->getFrontendOpts().Inputs[0].getFile();
// Set up diagnostics, capturing any diagnostics produced. // Set up diagnostics, capturing any diagnostics produced.
@ -2369,8 +2374,8 @@ void ASTUnit::CodeComplete(
CaptureDroppedDiagnostics Capture(true, CaptureDroppedDiagnostics Capture(true,
Clang->getDiagnostics(), Clang->getDiagnostics(),
StoredDiagnostics); StoredDiagnostics);
ProcessWarningOptions(Diag, Inv.getDiagnosticOpts()); ProcessWarningOptions(Diag, CCInvocation->getDiagnosticOpts());
// Create the target instance. // Create the target instance.
Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->setTarget(TargetInfo::CreateTargetInfo(
Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
@ -2426,7 +2431,7 @@ void ASTUnit::CodeComplete(
if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) { if (!llvm::sys::fs::getUniqueID(MainPath, MainID)) {
if (CompleteFileID == MainID && Line > 1) if (CompleteFileID == MainID && Line > 1)
OverrideMainBuffer = getMainBufferWithPrecompiledPreamble( OverrideMainBuffer = getMainBufferWithPrecompiledPreamble(
PCHContainerOps, Inv, false, Line - 1); PCHContainerOps, *CCInvocation, false, Line - 1);
} }
} }
} }

2
clang/lib/Frontend/ChainedIncludesSource.cpp
View File

@ -147,7 +147,7 @@ IntrusiveRefCntPtr<ExternalSemaSource> clang::createChainedIncludesSource(
std::unique_ptr<CompilerInstance> Clang( std::unique_ptr<CompilerInstance> Clang(
new CompilerInstance(CI.getPCHContainerOperations())); new CompilerInstance(CI.getPCHContainerOperations()));
Clang->setInvocation(std::move(CInvok)); Clang->setInvocation(CInvok.release());
Clang->setDiagnostics(Diags.get()); Clang->setDiagnostics(Diags.get());
Clang->setTarget(TargetInfo::CreateTargetInfo( Clang->setTarget(TargetInfo::CreateTargetInfo(
Clang->getDiagnostics(), Clang->getInvocation().TargetOpts)); Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));

14
clang/lib/Frontend/CompilerInstance.cpp
View File

@ -66,9 +66,8 @@ CompilerInstance::~CompilerInstance() {
assert(OutputFiles.empty() && "Still output files in flight?"); assert(OutputFiles.empty() && "Still output files in flight?");
} }
void CompilerInstance::setInvocation( void CompilerInstance::setInvocation(CompilerInvocation *Value) {
std::shared_ptr<CompilerInvocation> Value) { Invocation = Value;
Invocation = std::move(Value);
} }
bool CompilerInstance::shouldBuildGlobalModuleIndex() const { bool CompilerInstance::shouldBuildGlobalModuleIndex() const {
@ -1020,8 +1019,8 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
= ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap(); = ImportingInstance.getPreprocessor().getHeaderSearchInfo().getModuleMap();
// Construct a compiler invocation for creating this module. // Construct a compiler invocation for creating this module.
auto Invocation = IntrusiveRefCntPtr<CompilerInvocation> Invocation
std::make_shared<CompilerInvocation>(ImportingInstance.getInvocation()); (new CompilerInvocation(ImportingInstance.getInvocation()));
PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts(); PreprocessorOptions &PPOpts = Invocation->getPreprocessorOpts();
@ -1077,8 +1076,7 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
// module. // module.
CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(), CompilerInstance Instance(ImportingInstance.getPCHContainerOperations(),
/*BuildingModule=*/true); /*BuildingModule=*/true);
auto &Inv = *Invocation; Instance.setInvocation(&*Invocation);
Instance.setInvocation(std::move(Invocation));
Instance.createDiagnostics(new ForwardingDiagnosticConsumer( Instance.createDiagnostics(new ForwardingDiagnosticConsumer(
ImportingInstance.getDiagnosticClient()), ImportingInstance.getDiagnosticClient()),
@ -1100,7 +1098,7 @@ static bool compileModuleImpl(CompilerInstance &ImportingInstance,
// between all of the module CompilerInstances. Other than that, we don't // between all of the module CompilerInstances. Other than that, we don't
// want to produce any dependency output from the module build. // want to produce any dependency output from the module build.
Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector()); Instance.setModuleDepCollector(ImportingInstance.getModuleDepCollector());
Inv.getDependencyOutputOpts() = DependencyOutputOptions(); Invocation->getDependencyOutputOpts() = DependencyOutputOptions();
// Get or create the module map that we'll use to build this module. // Get or create the module map that we'll use to build this module.
std::string InferredModuleMapContent; std::string InferredModuleMapContent;

11
clang/lib/Frontend/CompilerInvocation.cpp
View File

@ -60,11 +60,12 @@ CompilerInvocationBase::CompilerInvocationBase()
PreprocessorOpts(new PreprocessorOptions()) {} PreprocessorOpts(new PreprocessorOptions()) {}
CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X) CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &X)
: LangOpts(new LangOptions(*X.getLangOpts())), : RefCountedBase<CompilerInvocation>(),
TargetOpts(new TargetOptions(X.getTargetOpts())), LangOpts(new LangOptions(*X.getLangOpts())),
DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())), TargetOpts(new TargetOptions(X.getTargetOpts())),
HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())), DiagnosticOpts(new DiagnosticOptions(X.getDiagnosticOpts())),
PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {} HeaderSearchOpts(new HeaderSearchOptions(X.getHeaderSearchOpts())),
PreprocessorOpts(new PreprocessorOptions(X.getPreprocessorOpts())) {}
CompilerInvocationBase::~CompilerInvocationBase() {} CompilerInvocationBase::~CompilerInvocationBase() {}

10
clang/lib/Frontend/CreateInvocationFromCommandLine.cpp
View File

@ -30,9 +30,9 @@ using namespace llvm::opt;
/// ///
/// \return A CompilerInvocation, or 0 if none was built for the given /// \return A CompilerInvocation, or 0 if none was built for the given
/// argument vector. /// argument vector.
std::unique_ptr<CompilerInvocation> clang::createInvocationFromCommandLine( CompilerInvocation *
ArrayRef<const char *> ArgList, clang::createInvocationFromCommandLine(ArrayRef<const char *> ArgList,
IntrusiveRefCntPtr<DiagnosticsEngine> Diags) { IntrusiveRefCntPtr<DiagnosticsEngine> Diags) {
if (!Diags.get()) { if (!Diags.get()) {
// No diagnostics engine was provided, so create our own diagnostics object // No diagnostics engine was provided, so create our own diagnostics object
// with the default options. // with the default options.
@ -93,12 +93,12 @@ std::unique_ptr<CompilerInvocation> clang::createInvocationFromCommandLine(
} }
const ArgStringList &CCArgs = Cmd.getArguments(); const ArgStringList &CCArgs = Cmd.getArguments();
auto CI = llvm::make_unique<CompilerInvocation>(); std::unique_ptr<CompilerInvocation> CI(new CompilerInvocation());
if (!CompilerInvocation::CreateFromArgs(*CI, if (!CompilerInvocation::CreateFromArgs(*CI,
const_cast<const char **>(CCArgs.data()), const_cast<const char **>(CCArgs.data()),
const_cast<const char **>(CCArgs.data()) + const_cast<const char **>(CCArgs.data()) +
CCArgs.size(), CCArgs.size(),
*Diags)) *Diags))
return nullptr; return nullptr;
return CI; return CI.release();
} }

5
clang/lib/StaticAnalyzer/Frontend/ModelInjector.cpp
View File

@ -62,7 +62,8 @@ void ModelInjector::onBodySynthesis(const NamedDecl *D) {
return; return;
} }
auto Invocation = std::make_shared<CompilerInvocation>(CI.getInvocation()); IntrusiveRefCntPtr<CompilerInvocation> Invocation(
new CompilerInvocation(CI.getInvocation()));
FrontendOptions &FrontendOpts = Invocation->getFrontendOpts(); FrontendOptions &FrontendOpts = Invocation->getFrontendOpts();
InputKind IK = IK_CXX; // FIXME InputKind IK = IK_CXX; // FIXME
@ -75,7 +76,7 @@ void ModelInjector::onBodySynthesis(const NamedDecl *D) {
// Modules are parsed by a separate CompilerInstance, so this code mimics that // Modules are parsed by a separate CompilerInstance, so this code mimics that
// behavior for models // behavior for models
CompilerInstance Instance(CI.getPCHContainerOperations()); CompilerInstance Instance(CI.getPCHContainerOperations());
Instance.setInvocation(std::move(Invocation)); Instance.setInvocation(&*Invocation);
Instance.createDiagnostics( Instance.createDiagnostics(
new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()), new ForwardingDiagnosticConsumer(CI.getDiagnosticClient()),
/*ShouldOwnClient=*/true); /*ShouldOwnClient=*/true);

15
clang/lib/Tooling/Tooling.cpp
View File

@ -275,13 +275,13 @@ bool ToolInvocation::run() {
Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(), Invocation->getPreprocessorOpts().addRemappedFile(It.getKey(),
Input.release()); Input.release());
} }
return runInvocation(BinaryName, Compilation.get(), std::move(Invocation), return runInvocation(BinaryName, Compilation.get(), Invocation.release(),
std::move(PCHContainerOps)); std::move(PCHContainerOps));
} }
bool ToolInvocation::runInvocation( bool ToolInvocation::runInvocation(
const char *BinaryName, clang::driver::Compilation *Compilation, const char *BinaryName, clang::driver::Compilation *Compilation,
std::shared_ptr<clang::CompilerInvocation> Invocation, clang::CompilerInvocation *Invocation,
std::shared_ptr<PCHContainerOperations> PCHContainerOps) { std::shared_ptr<PCHContainerOperations> PCHContainerOps) {
// Show the invocation, with -v. // Show the invocation, with -v.
if (Invocation->getHeaderSearchOpts().Verbose) { if (Invocation->getHeaderSearchOpts().Verbose) {
@ -290,17 +290,17 @@ bool ToolInvocation::runInvocation(
llvm::errs() << "\n"; llvm::errs() << "\n";
} }
return Action->runInvocation(std::move(Invocation), Files, return Action->runInvocation(Invocation, Files, std::move(PCHContainerOps),
std::move(PCHContainerOps), DiagConsumer); DiagConsumer);
} }
bool FrontendActionFactory::runInvocation( bool FrontendActionFactory::runInvocation(
std::shared_ptr<CompilerInvocation> Invocation, FileManager *Files, CompilerInvocation *Invocation, FileManager *Files,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
DiagnosticConsumer *DiagConsumer) { DiagnosticConsumer *DiagConsumer) {
// Create a compiler instance to handle the actual work. // Create a compiler instance to handle the actual work.
clang::CompilerInstance Compiler(std::move(PCHContainerOps)); clang::CompilerInstance Compiler(std::move(PCHContainerOps));
Compiler.setInvocation(std::move(Invocation)); Compiler.setInvocation(Invocation);
Compiler.setFileManager(Files); Compiler.setFileManager(Files);
// The FrontendAction can have lifetime requirements for Compiler or its // The FrontendAction can have lifetime requirements for Compiler or its
@ -474,8 +474,7 @@ class ASTBuilderAction : public ToolAction {
public: public:
ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {} ASTBuilderAction(std::vector<std::unique_ptr<ASTUnit>> &ASTs) : ASTs(ASTs) {}
bool runInvocation(std::shared_ptr<CompilerInvocation> Invocation, bool runInvocation(CompilerInvocation *Invocation, FileManager *Files,
FileManager *Files,
std::shared_ptr<PCHContainerOperations> PCHContainerOps, std::shared_ptr<PCHContainerOperations> PCHContainerOps,
DiagnosticConsumer *DiagConsumer) override { DiagnosticConsumer *DiagConsumer) override {
std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation( std::unique_ptr<ASTUnit> AST = ASTUnit::LoadFromCompilerInvocation(

7
clang/tools/c-index-test/core_main.cpp
View File

@ -140,7 +140,8 @@ static bool printSourceSymbols(ArrayRef<const char *> Args) {
ArgsWithProgName.append(Args.begin(), Args.end()); ArgsWithProgName.append(Args.begin(), Args.end());
IntrusiveRefCntPtr<DiagnosticsEngine> IntrusiveRefCntPtr<DiagnosticsEngine>
Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions)); Diags(CompilerInstance::createDiagnostics(new DiagnosticOptions));
auto CInvok = createInvocationFromCommandLine(ArgsWithProgName, Diags); IntrusiveRefCntPtr<CompilerInvocation>
CInvok(createInvocationFromCommandLine(ArgsWithProgName, Diags));
if (!CInvok) if (!CInvok)
return true; return true;
@ -151,8 +152,8 @@ static bool printSourceSymbols(ArrayRef<const char *> Args) {
/*WrappedAction=*/nullptr); /*WrappedAction=*/nullptr);
auto PCHContainerOps = std::make_shared<PCHContainerOperations>(); auto PCHContainerOps = std::make_shared<PCHContainerOperations>();
auto Unit = ASTUnit::LoadFromCompilerInvocationAction( std::unique_ptr<ASTUnit> Unit(ASTUnit::LoadFromCompilerInvocationAction(
std::move(CInvok), PCHContainerOps, Diags, IndexAction.get()); CInvok.get(), PCHContainerOps, Diags, IndexAction.get()));
if (!Unit) if (!Unit)
return true; return true;

2
clang/tools/clang-import-test/clang-import-test.cpp
View File

@ -157,7 +157,7 @@ BuildCompilerInstance(ArrayRef<const char *> ClangArgv) {
Inv->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo); Inv->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple(); Inv->getTargetOpts().Triple = llvm::sys::getDefaultTargetTriple();
Ins->setInvocation(std::move(Inv)); Ins->setInvocation(Inv.release());
TargetInfo *TI = TargetInfo::CreateTargetInfo( TargetInfo *TI = TargetInfo::CreateTargetInfo(
Ins->getDiagnostics(), Ins->getInvocation().TargetOpts); Ins->getDiagnostics(), Ins->getInvocation().TargetOpts);

4
clang/tools/diagtool/ShowEnabledWarnings.cpp
View File

@ -67,8 +67,8 @@ createDiagnostics(unsigned int argc, char **argv) {
SmallVector<const char *, 4> Args; SmallVector<const char *, 4> Args;
Args.push_back("diagtool"); Args.push_back("diagtool");
Args.append(argv, argv + argc); Args.append(argv, argv + argc);
std::unique_ptr<CompilerInvocation> Invocation = std::unique_ptr<CompilerInvocation> Invocation(
createInvocationFromCommandLine(Args, InterimDiags); createInvocationFromCommandLine(Args, InterimDiags));
if (!Invocation) if (!Invocation)
return nullptr; return nullptr;

9
clang/tools/libclang/CIndex.cpp
View File

@ -68,14 +68,13 @@ using namespace clang::cxcursor;
using namespace clang::cxtu; using namespace clang::cxtu;
using namespace clang::cxindex; using namespace clang::cxindex;
CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, CXTranslationUnit cxtu::MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU) {
std::unique_ptr<ASTUnit> AU) {
if (!AU) if (!AU)
return nullptr; return nullptr;
assert(CIdx); assert(CIdx);
CXTranslationUnit D = new CXTranslationUnitImpl(); CXTranslationUnit D = new CXTranslationUnitImpl();
D->CIdx = CIdx; D->CIdx = CIdx;
D->TheASTUnit = AU.release(); D->TheASTUnit = AU;
D->StringPool = new cxstring::CXStringPool(); D->StringPool = new cxstring::CXStringPool();
D->Diagnostics = nullptr; D->Diagnostics = nullptr;
D->OverridenCursorsPool = createOverridenCXCursorsPool(); D->OverridenCursorsPool = createOverridenCXCursorsPool();
@ -3232,7 +3231,7 @@ enum CXErrorCode clang_createTranslationUnit2(CXIndex CIdx,
/*CaptureDiagnostics=*/true, /*CaptureDiagnostics=*/true,
/*AllowPCHWithCompilerErrors=*/true, /*AllowPCHWithCompilerErrors=*/true,
/*UserFilesAreVolatile=*/true); /*UserFilesAreVolatile=*/true);
*out_TU = MakeCXTranslationUnit(CXXIdx, std::move(AU)); *out_TU = MakeCXTranslationUnit(CXXIdx, AU.release());
return *out_TU ? CXError_Success : CXError_Failure; return *out_TU ? CXError_Success : CXError_Failure;
} }
@ -3384,7 +3383,7 @@ clang_parseTranslationUnit_Impl(CXIndex CIdx, const char *source_filename,
if (isASTReadError(Unit ? Unit.get() : ErrUnit.get())) if (isASTReadError(Unit ? Unit.get() : ErrUnit.get()))
return CXError_ASTReadError; return CXError_ASTReadError;
*out_TU = MakeCXTranslationUnit(CXXIdx, std::move(Unit)); *out_TU = MakeCXTranslationUnit(CXXIdx, Unit.release());
return *out_TU ? CXError_Success : CXError_Failure; return *out_TU ? CXError_Success : CXError_Failure;
} }

19
clang/tools/libclang/CIndexCodeCompletion.cpp
View File

@ -279,12 +279,13 @@ struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults {
SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers; SmallVector<const llvm::MemoryBuffer *, 1> TemporaryBuffers;
/// \brief Allocator used to store globally cached code-completion results. /// \brief Allocator used to store globally cached code-completion results.
std::shared_ptr<clang::GlobalCodeCompletionAllocator> IntrusiveRefCntPtr<clang::GlobalCodeCompletionAllocator>
CachedCompletionAllocator; CachedCompletionAllocator;
/// \brief Allocator used to store code completion results. /// \brief Allocator used to store code completion results.
std::shared_ptr<clang::GlobalCodeCompletionAllocator> CodeCompletionAllocator; IntrusiveRefCntPtr<clang::GlobalCodeCompletionAllocator>
CodeCompletionAllocator;
/// \brief Context under which completion occurred. /// \brief Context under which completion occurred.
enum clang::CodeCompletionContext::Kind ContextKind; enum clang::CodeCompletionContext::Kind ContextKind;
@ -314,15 +315,15 @@ struct AllocatedCXCodeCompleteResults : public CXCodeCompleteResults {
/// ///
/// Used for debugging purposes only. /// Used for debugging purposes only.
static std::atomic<unsigned> CodeCompletionResultObjects; static std::atomic<unsigned> CodeCompletionResultObjects;
AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults( AllocatedCXCodeCompleteResults::AllocatedCXCodeCompleteResults(
IntrusiveRefCntPtr<FileManager> FileMgr) IntrusiveRefCntPtr<FileManager> FileMgr)
: CXCodeCompleteResults(), DiagOpts(new DiagnosticOptions), : CXCodeCompleteResults(),
DiagOpts(new DiagnosticOptions),
Diag(new DiagnosticsEngine( Diag(new DiagnosticsEngine(
IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)), IntrusiveRefCntPtr<DiagnosticIDs>(new DiagnosticIDs), &*DiagOpts)),
FileMgr(FileMgr), SourceMgr(new SourceManager(*Diag, *FileMgr)), FileMgr(FileMgr), SourceMgr(new SourceManager(*Diag, *FileMgr)),
CodeCompletionAllocator( CodeCompletionAllocator(new clang::GlobalCodeCompletionAllocator),
std::make_shared<clang::GlobalCodeCompletionAllocator>()),
Contexts(CXCompletionContext_Unknown), Contexts(CXCompletionContext_Unknown),
ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) { ContainerKind(CXCursor_InvalidCode), ContainerIsIncomplete(1) {
if (getenv("LIBCLANG_OBJTRACKING")) if (getenv("LIBCLANG_OBJTRACKING"))

3
clang/tools/libclang/CXTranslationUnit.h
View File

@ -38,8 +38,7 @@ struct CXTranslationUnitImpl {
namespace clang { namespace clang {
namespace cxtu { namespace cxtu {
CXTranslationUnitImpl *MakeCXTranslationUnit(CIndexer *CIdx, CXTranslationUnitImpl *MakeCXTranslationUnit(CIndexer *CIdx, ASTUnit *AU);
std::unique_ptr<ASTUnit> AU);
static inline ASTUnit *getASTUnit(CXTranslationUnit TU) { static inline ASTUnit *getASTUnit(CXTranslationUnit TU) {
if (!TU) if (!TU)

29
clang/tools/libclang/Indexing.cpp
View File

@ -476,19 +476,17 @@ static CXErrorCode clang_indexSourceFile_Impl(
// present it will be unused. // present it will be unused.
if (source_filename) if (source_filename)
Args->push_back(source_filename); Args->push_back(source_filename);
std::shared_ptr<CompilerInvocation> CInvok = IntrusiveRefCntPtr<CompilerInvocation>
createInvocationFromCommandLine(*Args, Diags); CInvok(createInvocationFromCommandLine(*Args, Diags));
if (!CInvok) if (!CInvok)
return CXError_Failure; return CXError_Failure;
// Recover resources if we crash before exiting this function. // Recover resources if we crash before exiting this function.
llvm::CrashRecoveryContextCleanupRegistrar< llvm::CrashRecoveryContextCleanupRegistrar<CompilerInvocation,
std::shared_ptr<CompilerInvocation>, llvm::CrashRecoveryContextReleaseRefCleanup<CompilerInvocation> >
llvm::CrashRecoveryContextDeleteCleanup< CInvokCleanup(CInvok.get());
std::shared_ptr<CompilerInvocation>>>
CInvokCleanup(&CInvok);
if (CInvok->getFrontendOpts().Inputs.empty()) if (CInvok->getFrontendOpts().Inputs.empty())
return CXError_Failure; return CXError_Failure;
@ -520,14 +518,13 @@ static CXErrorCode clang_indexSourceFile_Impl(
CInvok->getHeaderSearchOpts().ModuleFormat = CInvok->getHeaderSearchOpts().ModuleFormat =
CXXIdx->getPCHContainerOperations()->getRawReader().getFormat(); CXXIdx->getPCHContainerOperations()->getRawReader().getFormat();
auto Unit = ASTUnit::create(CInvok, Diags, CaptureDiagnostics, ASTUnit *Unit = ASTUnit::create(CInvok.get(), Diags, CaptureDiagnostics,
/*UserFilesAreVolatile=*/true); /*UserFilesAreVolatile=*/true);
if (!Unit) if (!Unit)
return CXError_InvalidArguments; return CXError_InvalidArguments;
auto *UPtr = Unit.get();
std::unique_ptr<CXTUOwner> CXTU( std::unique_ptr<CXTUOwner> CXTU(
new CXTUOwner(MakeCXTranslationUnit(CXXIdx, std::move(Unit)))); new CXTUOwner(MakeCXTranslationUnit(CXXIdx, Unit)));
// Recover resources if we crash before exiting this method. // Recover resources if we crash before exiting this method.
llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner> llvm::CrashRecoveryContextCleanupRegistrar<CXTUOwner>
@ -586,16 +583,16 @@ static CXErrorCode clang_indexSourceFile_Impl(
!PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse; !PrecompilePreamble ? 0 : 2 - CreatePreambleOnFirstParse;
DiagnosticErrorTrap DiagTrap(*Diags); DiagnosticErrorTrap DiagTrap(*Diags);
bool Success = ASTUnit::LoadFromCompilerInvocationAction( bool Success = ASTUnit::LoadFromCompilerInvocationAction(
std::move(CInvok), CXXIdx->getPCHContainerOperations(), Diags, CInvok.get(), CXXIdx->getPCHContainerOperations(), Diags,
IndexAction.get(), UPtr, Persistent, CXXIdx->getClangResourcesPath(), IndexAction.get(), Unit, Persistent, CXXIdx->getClangResourcesPath(),
OnlyLocalDecls, CaptureDiagnostics, PrecompilePreambleAfterNParses, OnlyLocalDecls, CaptureDiagnostics, PrecompilePreambleAfterNParses,
CacheCodeCompletionResults, CacheCodeCompletionResults,
/*IncludeBriefCommentsInCodeCompletion=*/false, /*IncludeBriefCommentsInCodeCompletion=*/false,
/*UserFilesAreVolatile=*/true); /*UserFilesAreVolatile=*/true);
if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics()) if (DiagTrap.hasErrorOccurred() && CXXIdx->getDisplayDiagnostics())
printDiagsToStderr(UPtr); printDiagsToStderr(Unit);
if (isASTReadError(UPtr)) if (isASTReadError(Unit))
return CXError_ASTReadError; return CXError_ASTReadError;
if (!Success) if (!Success)

4
clang/unittests/AST/ExternalASTSourceTest.cpp
View File

@ -49,14 +49,14 @@ bool testExternalASTSource(ExternalASTSource *Source,
CompilerInstance Compiler; CompilerInstance Compiler;
Compiler.createDiagnostics(); Compiler.createDiagnostics();
auto Invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *Invocation = new CompilerInvocation;
Invocation->getPreprocessorOpts().addRemappedFile( Invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", MemoryBuffer::getMemBuffer(FileContents).release()); "test.cc", MemoryBuffer::getMemBuffer(FileContents).release());
const char *Args[] = { "test.cc" }; const char *Args[] = { "test.cc" };
CompilerInvocation::CreateFromArgs(*Invocation, Args, CompilerInvocation::CreateFromArgs(*Invocation, Args,
Args + array_lengthof(Args), Args + array_lengthof(Args),
Compiler.getDiagnostics()); Compiler.getDiagnostics());
Compiler.setInvocation(std::move(Invocation)); Compiler.setInvocation(Invocation);
TestFrontendAction Action(Source); TestFrontendAction Action(Source);
return Compiler.ExecuteAction(Action); return Compiler.ExecuteAction(Action);

4
clang/unittests/Frontend/CodeGenActionTest.cpp
View File

@ -41,7 +41,7 @@ public:
TEST(CodeGenTest, TestNullCodeGen) { TEST(CodeGenTest, TestNullCodeGen) {
auto Invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *Invocation = new CompilerInvocation;
Invocation->getPreprocessorOpts().addRemappedFile( Invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", "test.cc",
MemoryBuffer::getMemBuffer("").release()); MemoryBuffer::getMemBuffer("").release());
@ -50,7 +50,7 @@ TEST(CodeGenTest, TestNullCodeGen) {
Invocation->getFrontendOpts().ProgramAction = EmitLLVM; Invocation->getFrontendOpts().ProgramAction = EmitLLVM;
Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance Compiler; CompilerInstance Compiler;
Compiler.setInvocation(std::move(Invocation)); Compiler.setInvocation(Invocation);
Compiler.createDiagnostics(); Compiler.createDiagnostics();
EXPECT_TRUE(Compiler.hasDiagnostics()); EXPECT_TRUE(Compiler.hasDiagnostics());

20
clang/unittests/Frontend/FrontendActionTest.cpp
View File

@ -79,7 +79,7 @@ private:
}; };
TEST(ASTFrontendAction, Sanity) { TEST(ASTFrontendAction, Sanity) {
auto invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *invocation = new CompilerInvocation;
invocation->getPreprocessorOpts().addRemappedFile( invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", "test.cc",
MemoryBuffer::getMemBuffer("int main() { float x; }").release()); MemoryBuffer::getMemBuffer("int main() { float x; }").release());
@ -88,7 +88,7 @@ TEST(ASTFrontendAction, Sanity) {
invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly; invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance compiler; CompilerInstance compiler;
compiler.setInvocation(std::move(invocation)); compiler.setInvocation(invocation);
compiler.createDiagnostics(); compiler.createDiagnostics();
TestASTFrontendAction test_action; TestASTFrontendAction test_action;
@ -99,7 +99,7 @@ TEST(ASTFrontendAction, Sanity) {
} }
TEST(ASTFrontendAction, IncrementalParsing) { TEST(ASTFrontendAction, IncrementalParsing) {
auto invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *invocation = new CompilerInvocation;
invocation->getPreprocessorOpts().addRemappedFile( invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", "test.cc",
MemoryBuffer::getMemBuffer("int main() { float x; }").release()); MemoryBuffer::getMemBuffer("int main() { float x; }").release());
@ -108,7 +108,7 @@ TEST(ASTFrontendAction, IncrementalParsing) {
invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly; invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance compiler; CompilerInstance compiler;
compiler.setInvocation(std::move(invocation)); compiler.setInvocation(invocation);
compiler.createDiagnostics(); compiler.createDiagnostics();
TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true); TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true);
@ -119,7 +119,7 @@ TEST(ASTFrontendAction, IncrementalParsing) {
} }
TEST(ASTFrontendAction, LateTemplateIncrementalParsing) { TEST(ASTFrontendAction, LateTemplateIncrementalParsing) {
auto invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *invocation = new CompilerInvocation;
invocation->getLangOpts()->CPlusPlus = true; invocation->getLangOpts()->CPlusPlus = true;
invocation->getLangOpts()->DelayedTemplateParsing = true; invocation->getLangOpts()->DelayedTemplateParsing = true;
invocation->getPreprocessorOpts().addRemappedFile( invocation->getPreprocessorOpts().addRemappedFile(
@ -135,7 +135,7 @@ TEST(ASTFrontendAction, LateTemplateIncrementalParsing) {
invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly; invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance compiler; CompilerInstance compiler;
compiler.setInvocation(std::move(invocation)); compiler.setInvocation(invocation);
compiler.createDiagnostics(); compiler.createDiagnostics();
TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true, TestASTFrontendAction test_action(/*enableIncrementalProcessing=*/true,
@ -172,7 +172,7 @@ public:
}; };
TEST(PreprocessorFrontendAction, EndSourceFile) { TEST(PreprocessorFrontendAction, EndSourceFile) {
auto Invocation = std::make_shared<CompilerInvocation>(); CompilerInvocation *Invocation = new CompilerInvocation;
Invocation->getPreprocessorOpts().addRemappedFile( Invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", "test.cc",
MemoryBuffer::getMemBuffer("int main() { float x; }").release()); MemoryBuffer::getMemBuffer("int main() { float x; }").release());
@ -181,7 +181,7 @@ TEST(PreprocessorFrontendAction, EndSourceFile) {
Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly; Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance Compiler; CompilerInstance Compiler;
Compiler.setInvocation(std::move(Invocation)); Compiler.setInvocation(Invocation);
Compiler.createDiagnostics(); Compiler.createDiagnostics();
TestPPCallbacks *Callbacks = new TestPPCallbacks; TestPPCallbacks *Callbacks = new TestPPCallbacks;
@ -231,7 +231,7 @@ struct TypoDiagnosticConsumer : public DiagnosticConsumer {
}; };
TEST(ASTFrontendAction, ExternalSemaSource) { TEST(ASTFrontendAction, ExternalSemaSource) {
auto Invocation = std::make_shared<CompilerInvocation>(); auto *Invocation = new CompilerInvocation;
Invocation->getLangOpts()->CPlusPlus = true; Invocation->getLangOpts()->CPlusPlus = true;
Invocation->getPreprocessorOpts().addRemappedFile( Invocation->getPreprocessorOpts().addRemappedFile(
"test.cc", MemoryBuffer::getMemBuffer("void fooo();\n" "test.cc", MemoryBuffer::getMemBuffer("void fooo();\n"
@ -242,7 +242,7 @@ TEST(ASTFrontendAction, ExternalSemaSource) {
Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly; Invocation->getFrontendOpts().ProgramAction = frontend::ParseSyntaxOnly;
Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu"; Invocation->getTargetOpts().Triple = "i386-unknown-linux-gnu";
CompilerInstance Compiler; CompilerInstance Compiler;
Compiler.setInvocation(std::move(Invocation)); Compiler.setInvocation(Invocation);
auto *TDC = new TypoDiagnosticConsumer; auto *TDC = new TypoDiagnosticConsumer;
Compiler.createDiagnostics(TDC, /*ShouldOwnClient=*/true); Compiler.createDiagnostics(TDC, /*ShouldOwnClient=*/true);
Compiler.setExternalSemaSource(new TypoExternalSemaSource(Compiler)); Compiler.setExternalSemaSource(new TypoExternalSemaSource(Compiler));