[clang] f690715 - Revert "[clang-repl] Land initial infrastructure for incremental parsing"
Vassil Vassilev via cfe-commits
cfe-commits at lists.llvm.org
Wed May 12 21:44:27 PDT 2021
Author: Vassil Vassilev
Date: 2021-05-13T04:44:19Z
New Revision: f6907152db3d70606817ffe28274c6a90b331bbc
URL: https://github.com/llvm/llvm-project/commit/f6907152db3d70606817ffe28274c6a90b331bbc
DIFF: https://github.com/llvm/llvm-project/commit/f6907152db3d70606817ffe28274c6a90b331bbc.diff
LOG: Revert "[clang-repl] Land initial infrastructure for incremental parsing"
This reverts commit 44a4000181e1a25027e87f2ae4e71cb876a7a275.
We are seeing build failures due to missing dependency to libSupport and
CMake Error at tools/clang/tools/clang-repl/cmake_install.cmake
file INSTALL cannot find
Added:
clang/unittests/CodeGen/IncrementalProcessingTest.cpp
Modified:
clang/include/clang/CodeGen/CodeGenAction.h
clang/include/clang/Frontend/FrontendAction.h
clang/lib/CMakeLists.txt
clang/lib/CodeGen/CodeGenAction.cpp
clang/lib/Frontend/FrontendAction.cpp
clang/test/CMakeLists.txt
clang/test/lit.cfg.py
clang/tools/CMakeLists.txt
clang/unittests/CMakeLists.txt
clang/unittests/CodeGen/CMakeLists.txt
Removed:
clang/include/clang/Interpreter/Interpreter.h
clang/include/clang/Interpreter/Transaction.h
clang/lib/Interpreter/CMakeLists.txt
clang/lib/Interpreter/IncrementalExecutor.cpp
clang/lib/Interpreter/IncrementalExecutor.h
clang/lib/Interpreter/IncrementalParser.cpp
clang/lib/Interpreter/IncrementalParser.h
clang/lib/Interpreter/Interpreter.cpp
clang/test/Interpreter/execute.cpp
clang/test/Interpreter/sanity.c
clang/tools/clang-repl/CMakeLists.txt
clang/tools/clang-repl/ClangRepl.cpp
clang/unittests/Interpreter/CMakeLists.txt
clang/unittests/Interpreter/IncrementalProcessingTest.cpp
clang/unittests/Interpreter/InterpreterTest.cpp
################################################################################
diff --git a/clang/include/clang/CodeGen/CodeGenAction.h b/clang/include/clang/CodeGen/CodeGenAction.h
index b5721344046d..1db904ea974c 100644
--- a/clang/include/clang/CodeGen/CodeGenAction.h
+++ b/clang/include/clang/CodeGen/CodeGenAction.h
@@ -19,7 +19,6 @@ namespace llvm {
namespace clang {
class BackendConsumer;
-class CodeGenerator;
class CodeGenAction : public ASTFrontendAction {
private:
@@ -78,8 +77,6 @@ class CodeGenAction : public ASTFrontendAction {
/// Take the LLVM context used by this action.
llvm::LLVMContext *takeLLVMContext();
- CodeGenerator *getCodeGenerator() const;
-
BackendConsumer *BEConsumer;
};
diff --git a/clang/include/clang/Frontend/FrontendAction.h b/clang/include/clang/Frontend/FrontendAction.h
index dfefddfb4527..319b3bc62cc4 100644
--- a/clang/include/clang/Frontend/FrontendAction.h
+++ b/clang/include/clang/Frontend/FrontendAction.h
@@ -234,7 +234,7 @@ class FrontendAction {
/// Perform any per-file post processing, deallocate per-file
/// objects, and run statistics and output file cleanup code.
- virtual void EndSourceFile();
+ void EndSourceFile();
/// @}
};
@@ -302,16 +302,15 @@ class PreprocessorFrontendAction : public FrontendAction {
/// some existing action's behavior. It implements every virtual method in
/// the FrontendAction interface by forwarding to the wrapped action.
class WrapperFrontendAction : public FrontendAction {
-protected:
std::unique_ptr<FrontendAction> WrappedAction;
+protected:
bool PrepareToExecuteAction(CompilerInstance &CI) override;
std::unique_ptr<ASTConsumer> CreateASTConsumer(CompilerInstance &CI,
StringRef InFile) override;
bool BeginInvocation(CompilerInstance &CI) override;
bool BeginSourceFileAction(CompilerInstance &CI) override;
void ExecuteAction() override;
- void EndSourceFile() override;
void EndSourceFileAction() override;
bool shouldEraseOutputFiles() override;
diff --git a/clang/include/clang/Interpreter/Interpreter.h b/clang/include/clang/Interpreter/Interpreter.h
deleted file mode 100644
index d4dd8731da18..000000000000
--- a/clang/include/clang/Interpreter/Interpreter.h
+++ /dev/null
@@ -1,71 +0,0 @@
-//===--- Interpreter.h - Incremental Compilation and Execution---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines the component which performs incremental code
-// compilation and execution.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_INTERPRETER_INTERPRETER_H
-#define LLVM_CLANG_INTERPRETER_INTERPRETER_H
-
-#include "clang/Interpreter/Transaction.h"
-
-#include "llvm/Support/Error.h"
-
-#include <memory>
-#include <vector>
-
-namespace llvm {
-namespace orc {
-class ThreadSafeContext;
-}
-class Module;
-} // namespace llvm
-
-namespace clang {
-
-class CompilerInstance;
-class DeclGroupRef;
-class IncrementalExecutor;
-class IncrementalParser;
-
-/// Create a pre-configured \c CompilerInstance for incremental processing.
-class IncrementalCompilerBuilder {
-public:
- static llvm::Expected<std::unique_ptr<CompilerInstance>>
- create(std::vector<const char *> &ClangArgv);
-};
-
-/// Provides top-level interfaces for incremental compilation and execution.
-class Interpreter {
- std::unique_ptr<llvm::orc::ThreadSafeContext> TSCtx;
- std::unique_ptr<IncrementalParser> IncrParser;
- std::unique_ptr<IncrementalExecutor> IncrExecutor;
-
- Interpreter(std::unique_ptr<CompilerInstance> CI, llvm::Error &Err);
-
-public:
- ~Interpreter();
- static llvm::Expected<std::unique_ptr<Interpreter>>
- create(std::unique_ptr<CompilerInstance> CI);
- const CompilerInstance *getCompilerInstance() const;
- llvm::Expected<Transaction &> Parse(llvm::StringRef Code);
- llvm::Error Execute(Transaction &T);
- llvm::Error ParseAndExecute(llvm::StringRef Code) {
- auto ErrOrTransaction = Parse(Code);
- if (auto Err = ErrOrTransaction.takeError())
- return Err;
- if (ErrOrTransaction->TheModule)
- return Execute(*ErrOrTransaction);
- return llvm::Error::success();
- }
-};
-} // namespace clang
-
-#endif // LLVM_CLANG_INTERPRETER_INTERPRETER_H
diff --git a/clang/include/clang/Interpreter/Transaction.h b/clang/include/clang/Interpreter/Transaction.h
deleted file mode 100644
index 15639d4af0f9..000000000000
--- a/clang/include/clang/Interpreter/Transaction.h
+++ /dev/null
@@ -1,39 +0,0 @@
-//===--- Transaction.h - Incremental Compilation and Execution---*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file defines utilities tracking the incrementally processed pieces of
-// code.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_INTERPRETER_TRANSACTION_H
-#define LLVM_CLANG_INTERPRETER_TRANSACTION_H
-
-#include <memory>
-#include <vector>
-
-namespace llvm {
-class Module;
-}
-
-namespace clang {
-
-class DeclGroupRef;
-
-/// The class keeps track of various objects created as part of processing
-/// incremental inputs.
-struct Transaction {
- /// The decls created for the input.
- std::vector<clang::DeclGroupRef> Decls;
-
- /// The llvm IR produced for the input.
- std::unique_ptr<llvm::Module> TheModule;
-};
-} // namespace clang
-
-#endif // LLVM_CLANG_INTERPRETER_TRANSACTION_H
diff --git a/clang/lib/CMakeLists.txt b/clang/lib/CMakeLists.txt
index 2b49fb9e96f0..be09c0c351f3 100644
--- a/clang/lib/CMakeLists.txt
+++ b/clang/lib/CMakeLists.txt
@@ -25,4 +25,3 @@ add_subdirectory(IndexSerialization)
add_subdirectory(StaticAnalyzer)
add_subdirectory(Format)
add_subdirectory(Testing)
-add_subdirectory(Interpreter)
diff --git a/clang/lib/CodeGen/CodeGenAction.cpp b/clang/lib/CodeGen/CodeGenAction.cpp
index 02dcea286505..d33a4797430b 100644
--- a/clang/lib/CodeGen/CodeGenAction.cpp
+++ b/clang/lib/CodeGen/CodeGenAction.cpp
@@ -885,10 +885,6 @@ llvm::LLVMContext *CodeGenAction::takeLLVMContext() {
return VMContext;
}
-CodeGenerator *CodeGenAction::getCodeGenerator() const {
- return BEConsumer->getCodeGenerator();
-}
-
static std::unique_ptr<raw_pwrite_stream>
GetOutputStream(CompilerInstance &CI, StringRef InFile, BackendAction Action) {
switch (Action) {
diff --git a/clang/lib/Frontend/FrontendAction.cpp b/clang/lib/Frontend/FrontendAction.cpp
index 7ff4812c6800..11b25b106627 100644
--- a/clang/lib/Frontend/FrontendAction.cpp
+++ b/clang/lib/Frontend/FrontendAction.cpp
@@ -1087,7 +1087,6 @@ bool WrapperFrontendAction::BeginSourceFileAction(CompilerInstance &CI) {
void WrapperFrontendAction::ExecuteAction() {
WrappedAction->ExecuteAction();
}
-void WrapperFrontendAction::EndSourceFile() { WrappedAction->EndSourceFile(); }
void WrapperFrontendAction::EndSourceFileAction() {
WrappedAction->EndSourceFileAction();
}
diff --git a/clang/lib/Interpreter/CMakeLists.txt b/clang/lib/Interpreter/CMakeLists.txt
deleted file mode 100644
index e7dadba1affb..000000000000
--- a/clang/lib/Interpreter/CMakeLists.txt
+++ /dev/null
@@ -1,22 +0,0 @@
-set(LLVM_LINK_COMPONENTS
- core
- native
- OrcJit
- Target
- )
-
-add_clang_library(clangInterpreter
- IncrementalExecutor.cpp
- IncrementalParser.cpp
- Interpreter.cpp
-
- LINK_LIBS
- clangAST
- clangAnalysis
- clangBasic
- clangEdit
- clangLex
- clangSema
- clangCodeGen
- clangFrontendTool
- )
diff --git a/clang/lib/Interpreter/IncrementalExecutor.cpp b/clang/lib/Interpreter/IncrementalExecutor.cpp
deleted file mode 100644
index f999e5eceaed..000000000000
--- a/clang/lib/Interpreter/IncrementalExecutor.cpp
+++ /dev/null
@@ -1,61 +0,0 @@
-//===--- IncrementalExecutor.cpp - Incremental Execution --------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the class which performs incremental code execution.
-//
-//===----------------------------------------------------------------------===//
-
-#include "IncrementalExecutor.h"
-
-#include "llvm/ExecutionEngine/ExecutionEngine.h"
-#include "llvm/ExecutionEngine/Orc/CompileUtils.h"
-#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
-#include "llvm/ExecutionEngine/Orc/IRCompileLayer.h"
-#include "llvm/ExecutionEngine/Orc/LLJIT.h"
-#include "llvm/ExecutionEngine/Orc/RTDyldObjectLinkingLayer.h"
-#include "llvm/ExecutionEngine/SectionMemoryManager.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/ManagedStatic.h"
-#include "llvm/Support/TargetSelect.h"
-
-namespace clang {
-
-IncrementalExecutor::IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC,
- llvm::Error &Err)
- : TSCtx(TSC) {
- using namespace llvm::orc;
- llvm::ErrorAsOutParameter EAO(&Err);
-
- if (auto JitOrErr = LLJITBuilder().create())
- Jit = std::move(*JitOrErr);
- else {
- Err = JitOrErr.takeError();
- return;
- }
-
- const char Pref = Jit->getDataLayout().getGlobalPrefix();
- // Discover symbols from the process as a fallback.
- if (auto PSGOrErr = DynamicLibrarySearchGenerator::GetForCurrentProcess(Pref))
- Jit->getMainJITDylib().addGenerator(std::move(*PSGOrErr));
- else {
- Err = PSGOrErr.takeError();
- return;
- }
-}
-
-IncrementalExecutor::~IncrementalExecutor() {}
-
-llvm::Error IncrementalExecutor::addModule(std::unique_ptr<llvm::Module> M) {
- return Jit->addIRModule(llvm::orc::ThreadSafeModule(std::move(M), TSCtx));
-}
-
-llvm::Error IncrementalExecutor::runCtors() const {
- return Jit->initialize(Jit->getMainJITDylib());
-}
-
-} // end namespace clang
diff --git a/clang/lib/Interpreter/IncrementalExecutor.h b/clang/lib/Interpreter/IncrementalExecutor.h
deleted file mode 100644
index c4e33a390942..000000000000
--- a/clang/lib/Interpreter/IncrementalExecutor.h
+++ /dev/null
@@ -1,46 +0,0 @@
-//===--- IncrementalExecutor.h - Incremental Execution ----------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the class which performs incremental code execution.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H
-#define LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H
-
-#include "llvm/ADT/StringRef.h"
-#include "llvm/ExecutionEngine/Orc/ExecutionUtils.h"
-
-#include <memory>
-
-namespace llvm {
-class Error;
-class Module;
-namespace orc {
-class LLJIT;
-class ThreadSafeContext;
-} // namespace orc
-} // namespace llvm
-
-namespace clang {
-class IncrementalExecutor {
- using CtorDtorIterator = llvm::orc::CtorDtorIterator;
- std::unique_ptr<llvm::orc::LLJIT> Jit;
- llvm::orc::ThreadSafeContext &TSCtx;
-
-public:
- IncrementalExecutor(llvm::orc::ThreadSafeContext &TSC, llvm::Error &Err);
- ~IncrementalExecutor();
-
- llvm::Error addModule(std::unique_ptr<llvm::Module> M);
- llvm::Error runCtors() const;
-};
-
-} // end namespace clang
-
-#endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALEXECUTOR_H
diff --git a/clang/lib/Interpreter/IncrementalParser.cpp b/clang/lib/Interpreter/IncrementalParser.cpp
deleted file mode 100644
index 70baabfeb8fb..000000000000
--- a/clang/lib/Interpreter/IncrementalParser.cpp
+++ /dev/null
@@ -1,254 +0,0 @@
-//===--------- IncrementalParser.cpp - Incremental Compilation -----------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the class which performs incremental code compilation.
-//
-//===----------------------------------------------------------------------===//
-
-#include "IncrementalParser.h"
-
-#include "clang/CodeGen/BackendUtil.h"
-#include "clang/CodeGen/CodeGenAction.h"
-#include "clang/CodeGen/ModuleBuilder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendAction.h"
-#include "clang/FrontendTool/Utils.h"
-#include "clang/Parse/Parser.h"
-#include "clang/Sema/Sema.h"
-
-#include "llvm/Option/ArgList.h"
-#include "llvm/Support/CrashRecoveryContext.h"
-#include "llvm/Support/Error.h"
-#include "llvm/Support/Timer.h"
-
-#include <sstream>
-
-namespace clang {
-
-/// A custom action enabling the incremental processing functionality.
-///
-/// The usual \p FrontendAction expects one call to ExecuteAction and once it
-/// sees a call to \p EndSourceFile it deletes some of the important objects
-/// such as \p Preprocessor and \p Sema assuming no further input will come.
-///
-/// \p IncrementalAction ensures it keep its underlying action's objects alive
-/// as long as the \p IncrementalParser needs them.
-///
-class IncrementalAction : public WrapperFrontendAction {
-private:
- bool IsTerminating = false;
-
-public:
- IncrementalAction(CompilerInstance &CI, llvm::LLVMContext &LLVMCtx,
- llvm::Error &Err)
- : WrapperFrontendAction([&]() {
- llvm::ErrorAsOutParameter EAO(&Err);
- std::unique_ptr<FrontendAction> Act;
- switch (CI.getFrontendOpts().ProgramAction) {
- default:
- Err = llvm::createStringError(
- std::errc::state_not_recoverable,
- "Driver initialization failed. "
- "Incremental mode for action is not supported");
- return Act;
- case frontend::ASTDump:
- LLVM_FALLTHROUGH;
- case frontend::ASTPrint:
- LLVM_FALLTHROUGH;
- case frontend::ParseSyntaxOnly:
- Act = CreateFrontendAction(CI);
- break;
- case frontend::EmitObj:
- LLVM_FALLTHROUGH;
- case frontend::EmitLLVMOnly:
- Act.reset(new EmitLLVMOnlyAction(&LLVMCtx));
- break;
- }
- return Act;
- }()) {}
- FrontendAction *getWrapped() const { return WrappedAction.get(); }
- void ExecuteAction() override {
- CompilerInstance &CI = getCompilerInstance();
- assert(CI.hasPreprocessor() && "No PP!");
-
- // FIXME: Move the truncation aspect of this into Sema, we delayed this till
- // here so the source manager would be initialized.
- if (hasCodeCompletionSupport() &&
- !CI.getFrontendOpts().CodeCompletionAt.FileName.empty())
- CI.createCodeCompletionConsumer();
-
- // Use a code completion consumer?
- CodeCompleteConsumer *CompletionConsumer = nullptr;
- if (CI.hasCodeCompletionConsumer())
- CompletionConsumer = &CI.getCodeCompletionConsumer();
-
- Preprocessor &PP = CI.getPreprocessor();
- PP.enableIncrementalProcessing();
- PP.EnterMainSourceFile();
-
- if (!CI.hasSema())
- CI.createSema(getTranslationUnitKind(), CompletionConsumer);
- }
-
- // Do not terminate after processing the input. This allows us to keep various
- // clang objects alive and to incrementally grow the current TU.
- void EndSourceFile() override {
- // The WrappedAction can be nullptr if we issued an error in the ctor.
- if (IsTerminating && getWrapped())
- WrapperFrontendAction::EndSourceFile();
- }
-
- void FinalizeAction() {
- assert(!IsTerminating && "Already finalized!");
- IsTerminating = true;
- EndSourceFile();
- }
-};
-
-IncrementalParser::IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
- llvm::LLVMContext &LLVMCtx,
- llvm::Error &Err)
- : CI(std::move(Instance)) {
- llvm::ErrorAsOutParameter EAO(&Err);
- Act = std::make_unique<IncrementalAction>(*CI, LLVMCtx, Err);
- if (Err)
- return;
- CI->ExecuteAction(*Act);
- Consumer = &CI->getASTConsumer();
- P.reset(
- new Parser(CI->getPreprocessor(), CI->getSema(), /*SkipBodies=*/false));
- P->Initialize();
-}
-
-IncrementalParser::~IncrementalParser() { Act->FinalizeAction(); }
-
-llvm::Expected<Transaction &> IncrementalParser::ParseOrWrapTopLevelDecl() {
- DiagnosticsEngine &Diags = getCI()->getDiagnostics();
-
- if (Diags.hasErrorOccurred())
- llvm::report_fatal_error("Previous input had errors, "
- "recovery not yet supported",
- /*GenCrashDiag=*/false);
-
- // Recover resources if we crash before exiting this method.
- Sema &S = CI->getSema();
- llvm::CrashRecoveryContextCleanupRegistrar<Sema> CleanupSema(&S);
- Sema::GlobalEagerInstantiationScope GlobalInstantiations(S, /*Enabled=*/true);
- Sema::LocalEagerInstantiationScope LocalInstantiations(S);
-
- // Skip previous eof due to last incremental input.
- if (P->getCurToken().is(tok::eof))
- P->ConsumeToken();
-
- Transactions.emplace_back(Transaction());
- Transaction &LastTransaction = Transactions.back();
-
- Parser::DeclGroupPtrTy ADecl;
- for (bool AtEOF = P->ParseFirstTopLevelDecl(ADecl); !AtEOF;
- AtEOF = P->ParseTopLevelDecl(ADecl)) {
- // If we got a null return and something *was* parsed, ignore it. This
- // is due to a top-level semicolon, an action override, or a parse error
- // skipping something.
- if (ADecl && !Consumer->HandleTopLevelDecl(ADecl.get()))
- return llvm::make_error<llvm::StringError>("Parsing failed. "
- "The consumer rejected a decl",
- std::error_code());
- LastTransaction.Decls.push_back(ADecl.get());
- }
-
- // Process any TopLevelDecls generated by #pragma weak.
- for (Decl *D : S.WeakTopLevelDecls()) {
- DeclGroupRef DGR(D);
- LastTransaction.Decls.push_back(DGR);
- Consumer->HandleTopLevelDecl(DGR);
- }
-
- LocalInstantiations.perform();
- GlobalInstantiations.perform();
-
- Consumer->HandleTranslationUnit(S.getASTContext());
-
- if (Diags.hasErrorOccurred())
- return llvm::make_error<llvm::StringError>("Parsing failed.",
- std::error_code());
-
- return LastTransaction;
-}
-
-static CodeGenerator *getCodeGen(FrontendAction *Act) {
- IncrementalAction *IncrAct = static_cast<IncrementalAction *>(Act);
- FrontendAction *WrappedAct = IncrAct->getWrapped();
- if (!WrappedAct->hasIRSupport())
- return nullptr;
- return static_cast<CodeGenAction *>(WrappedAct)->getCodeGenerator();
-}
-
-llvm::Expected<Transaction &> IncrementalParser::Parse(llvm::StringRef input) {
- Preprocessor &PP = CI->getPreprocessor();
- assert(PP.isIncrementalProcessingEnabled() && "Not in incremental mode!?");
-
- std::ostringstream SourceName;
- SourceName << "input_line_" << InputCount++;
-
- // Create an uninitialized memory buffer, copy code in and append "\n"
- size_t InputSize = input.size(); // don't include trailing 0
- // MemBuffer size should *not* include terminating zero
- std::unique_ptr<llvm::MemoryBuffer> MB(
- llvm::WritableMemoryBuffer::getNewUninitMemBuffer(InputSize + 1,
- SourceName.str()));
- char *MBStart = const_cast<char *>(MB->getBufferStart());
- memcpy(MBStart, input.data(), InputSize);
- MBStart[InputSize] = '\n';
-
- SourceManager &SM = CI->getSourceManager();
-
- // FIXME: Create SourceLocation, which will allow clang to order the overload
- // candidates for example
- SourceLocation NewLoc = SM.getLocForStartOfFile(SM.getMainFileID());
-
- // Create FileID for the current buffer.
- FileID FID = SM.createFileID(std::move(MB), SrcMgr::C_User, /*LoadedID=*/0,
- /*LoadedOffset=*/0, NewLoc);
-
- // NewLoc only used for diags.
- if (PP.EnterSourceFile(FID, /*DirLookup=*/0, NewLoc))
- return llvm::make_error<llvm::StringError>("Parsing failed. "
- "Cannot enter source file.",
- std::error_code());
-
- auto ErrOrTransaction = ParseOrWrapTopLevelDecl();
- if (auto Err = ErrOrTransaction.takeError())
- return std::move(Err);
-
- if (PP.getLangOpts().DelayedTemplateParsing) {
- // Microsoft-specific:
- // Late parsed templates can leave unswallowed "macro"-like tokens.
- // They will seriously confuse the Parser when entering the next
- // source file. So lex until we are EOF.
- Token Tok;
- do {
- PP.Lex(Tok);
- } while (Tok.isNot(tok::eof));
- }
-
- Token AssertTok;
- PP.Lex(AssertTok);
- assert(AssertTok.is(tok::eof) &&
- "Lexer must be EOF when starting incremental parse!");
-
- if (CodeGenerator *CG = getCodeGen(Act.get())) {
- std::unique_ptr<llvm::Module> M(CG->ReleaseModule());
- CG->StartModule("incr_module_" + std::to_string(Transactions.size()),
- M->getContext());
-
- ErrOrTransaction->TheModule = std::move(M);
- }
-
- return ErrOrTransaction;
-}
-} // end namespace clang
diff --git a/clang/lib/Interpreter/IncrementalParser.h b/clang/lib/Interpreter/IncrementalParser.h
deleted file mode 100644
index 2ebc64e5930e..000000000000
--- a/clang/lib/Interpreter/IncrementalParser.h
+++ /dev/null
@@ -1,77 +0,0 @@
-//===--- IncrementalParser.h - Incremental Compilation ----------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the class which performs incremental code compilation.
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H
-#define LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H
-
-#include "clang/Interpreter/Transaction.h"
-
-#include "llvm/ADT/ArrayRef.h"
-#include "llvm/ADT/StringRef.h"
-#include "llvm/Support/Error.h"
-
-#include <list>
-#include <memory>
-namespace llvm {
-class LLVMContext;
-}
-
-namespace clang {
-class ASTConsumer;
-class CompilerInstance;
-class CodeGenerator;
-class DeclGroupRef;
-class FrontendAction;
-class IncrementalAction;
-class Parser;
-
-/// Provides support for incremental compilation. Keeps track of the state
-/// changes between the subsequent incremental input.
-///
-class IncrementalParser {
- /// Long-lived, incremental parsing action.
- std::unique_ptr<IncrementalAction> Act;
-
- /// Compiler instance performing the incremental compilation.
- std::unique_ptr<CompilerInstance> CI;
-
- /// Parser.
- std::unique_ptr<Parser> P;
-
- /// Consumer to process the produced top level decls. Owned by Act.
- ASTConsumer *Consumer = nullptr;
-
- /// Counts the number of direct user input lines that have been parsed.
- unsigned InputCount = 0;
-
- /// List containing every information about every incrementally parsed piece
- /// of code.
- std::list<Transaction> Transactions;
-
-public:
- IncrementalParser(std::unique_ptr<CompilerInstance> Instance,
- llvm::LLVMContext &LLVMCtx, llvm::Error &Err);
- ~IncrementalParser();
-
- const CompilerInstance *getCI() const { return CI.get(); }
-
- /// Parses incremental input by creating an in-memory file.
- ///\returns a \c Transaction which holds information about the \c Decls and
- /// \c llvm::Module corresponding to the input.
- llvm::Expected<Transaction &> Parse(llvm::StringRef Input);
-
-private:
- llvm::Expected<Transaction &> ParseOrWrapTopLevelDecl();
-};
-} // end namespace clang
-
-#endif // LLVM_CLANG_LIB_INTERPRETER_INCREMENTALPARSER_H
diff --git a/clang/lib/Interpreter/Interpreter.cpp b/clang/lib/Interpreter/Interpreter.cpp
deleted file mode 100644
index 8de38c0afcd9..000000000000
--- a/clang/lib/Interpreter/Interpreter.cpp
+++ /dev/null
@@ -1,220 +0,0 @@
-//===------ Interpreter.cpp - Incremental Compilation and Execution -------===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements the component which performs incremental code
-// compilation and execution.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Interpreter/Interpreter.h"
-
-#include "IncrementalExecutor.h"
-#include "IncrementalParser.h"
-
-#include "clang/Basic/TargetInfo.h"
-#include "clang/CodeGen/ModuleBuilder.h"
-#include "clang/CodeGen/ObjectFilePCHContainerOperations.h"
-#include "clang/Driver/Compilation.h"
-#include "clang/Driver/Driver.h"
-#include "clang/Driver/Job.h"
-#include "clang/Driver/Options.h"
-#include "clang/Driver/Tool.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/TextDiagnosticBuffer.h"
-#include "clang/Lex/PreprocessorOptions.h"
-
-#include "llvm/IR/Module.h"
-#include "llvm/Support/Host.h"
-
-using namespace clang;
-
-// FIXME: Figure out how to unify with namespace init_convenience from
-// tools/clang-import-test/clang-import-test.cpp and
-// examples/clang-interpreter/main.cpp
-namespace {
-/// Retrieves the clang CC1 specific flags out of the compilation's jobs.
-/// \returns NULL on error.
-static llvm::Expected<const llvm::opt::ArgStringList *>
-GetCC1Arguments(DiagnosticsEngine *Diagnostics,
- driver::Compilation *Compilation) {
- // We expect to get back exactly one Command job, if we didn't something
- // failed. Extract that job from the Compilation.
- const driver::JobList &Jobs = Compilation->getJobs();
- if (!Jobs.size() || !isa<driver::Command>(*Jobs.begin()))
- return llvm::createStringError(std::errc::state_not_recoverable,
- "Driver initialization failed. "
- "Unable to create a driver job");
-
- // The one job we find should be to invoke clang again.
- const driver::Command *Cmd = cast<driver::Command>(&(*Jobs.begin()));
- if (llvm::StringRef(Cmd->getCreator().getName()) != "clang")
- return llvm::createStringError(std::errc::state_not_recoverable,
- "Driver initialization failed");
-
- return &Cmd->getArguments();
-}
-
-static llvm::Expected<std::unique_ptr<CompilerInstance>>
-CreateCI(const llvm::opt::ArgStringList &Argv) {
- std::unique_ptr<CompilerInstance> Clang(new CompilerInstance());
- IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
-
- // Register the support for object-file-wrapped Clang modules.
- // FIXME: Clang should register these container operations automatically.
- auto PCHOps = Clang->getPCHContainerOperations();
- PCHOps->registerWriter(std::make_unique<ObjectFilePCHContainerWriter>());
- PCHOps->registerReader(std::make_unique<ObjectFilePCHContainerReader>());
-
- // Buffer diagnostics from argument parsing so that we can output them using
- // a well formed diagnostic object.
- IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
- TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
- DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
- bool Success = CompilerInvocation::CreateFromArgs(
- Clang->getInvocation(), llvm::makeArrayRef(Argv.begin(), Argv.size()),
- Diags);
-
- // Infer the builtin include path if unspecified.
- if (Clang->getHeaderSearchOpts().UseBuiltinIncludes &&
- Clang->getHeaderSearchOpts().ResourceDir.empty())
- Clang->getHeaderSearchOpts().ResourceDir =
- CompilerInvocation::GetResourcesPath(Argv[0], nullptr);
-
- // Create the actual diagnostics engine.
- Clang->createDiagnostics();
- if (!Clang->hasDiagnostics())
- return llvm::createStringError(std::errc::state_not_recoverable,
- "Initialization failed. "
- "Unable to create diagnostics engine");
-
- DiagsBuffer->FlushDiagnostics(Clang->getDiagnostics());
- if (!Success)
- return llvm::createStringError(std::errc::state_not_recoverable,
- "Initialization failed. "
- "Unable to flush diagnostics");
-
- // FIXME: Merge with CompilerInstance::ExecuteAction.
- llvm::MemoryBuffer *MB = llvm::MemoryBuffer::getMemBuffer("").release();
- Clang->getPreprocessorOpts().addRemappedFile("<<< inputs >>>", MB);
-
- Clang->setTarget(TargetInfo::CreateTargetInfo(
- Clang->getDiagnostics(), Clang->getInvocation().TargetOpts));
- if (!Clang->hasTarget())
- return llvm::createStringError(std::errc::state_not_recoverable,
- "Initialization failed. "
- "Target is missing");
-
- Clang->getTarget().adjust(Clang->getLangOpts());
-
- return std::move(Clang);
-}
-
-} // anonymous namespace
-
-llvm::Expected<std::unique_ptr<CompilerInstance>>
-IncrementalCompilerBuilder::create(std::vector<const char *> &ClangArgv) {
-
- // If we don't know ClangArgv0 or the address of main() at this point, try
- // to guess it anyway (it's possible on some platforms).
- std::string MainExecutableName =
- llvm::sys::fs::getMainExecutable(nullptr, nullptr);
-
- ClangArgv.insert(ClangArgv.begin(), MainExecutableName.c_str());
-
- // Prepending -c to force the driver to do something if no action was
- // specified. By prepending we allow users to override the default
- // action and use other actions in incremental mode.
- // FIXME: Print proper driver diagnostics if the driver flags are wrong.
- ClangArgv.insert(ClangArgv.begin() + 1, "-c");
-
- if (!llvm::is_contained(ClangArgv, " -x")) {
- // We do C++ by default; append right after argv[0] if no "-x" given
- ClangArgv.push_back("-x");
- ClangArgv.push_back("c++");
- }
-
- // Put a dummy C++ file on to ensure there's at least one compile job for the
- // driver to construct.
- ClangArgv.push_back("<<< inputs >>>");
-
- CompilerInvocation Invocation;
- // Buffer diagnostics from argument parsing so that we can output them using a
- // well formed diagnostic object.
- IntrusiveRefCntPtr<DiagnosticIDs> DiagID(new DiagnosticIDs());
- IntrusiveRefCntPtr<DiagnosticOptions> DiagOpts = new DiagnosticOptions();
- TextDiagnosticBuffer *DiagsBuffer = new TextDiagnosticBuffer;
- DiagnosticsEngine Diags(DiagID, &*DiagOpts, DiagsBuffer);
- unsigned MissingArgIndex, MissingArgCount;
- const llvm::opt::OptTable &Opts = driver::getDriverOptTable();
- llvm::opt::InputArgList ParsedArgs =
- Opts.ParseArgs(ArrayRef<const char *>(ClangArgv).slice(1),
- MissingArgIndex, MissingArgCount);
- ParseDiagnosticArgs(*DiagOpts, ParsedArgs, &Diags);
-
- driver::Driver Driver(/*MainBinaryName=*/ClangArgv[0],
- llvm::sys::getDefaultTargetTriple(), Diags);
- Driver.setCheckInputsExist(false); // the input comes from mem buffers
- llvm::ArrayRef<const char *> RF = llvm::makeArrayRef(ClangArgv);
- std::unique_ptr<driver::Compilation> Compilation(Driver.BuildCompilation(RF));
-
- if (Compilation->getArgs().hasArg(driver::options::OPT_v))
- Compilation->getJobs().Print(llvm::errs(), "\n", /*Quote=*/false);
-
- auto ErrOrCC1Args = GetCC1Arguments(&Diags, Compilation.get());
- if (auto Err = ErrOrCC1Args.takeError())
- return std::move(Err);
-
- return CreateCI(**ErrOrCC1Args);
-}
-
-Interpreter::Interpreter(std::unique_ptr<CompilerInstance> CI,
- llvm::Error &Err) {
- llvm::ErrorAsOutParameter EAO(&Err);
- auto LLVMCtx = std::make_unique<llvm::LLVMContext>();
- TSCtx = std::make_unique<llvm::orc::ThreadSafeContext>(std::move(LLVMCtx));
- IncrParser = std::make_unique<IncrementalParser>(std::move(CI),
- *TSCtx->getContext(), Err);
-}
-
-Interpreter::~Interpreter() {}
-
-llvm::Expected<std::unique_ptr<Interpreter>>
-Interpreter::create(std::unique_ptr<CompilerInstance> CI) {
- llvm::Error Err = llvm::Error::success();
- auto Interp =
- std::unique_ptr<Interpreter>(new Interpreter(std::move(CI), Err));
- if (Err)
- return std::move(Err);
- return std::move(Interp);
-}
-
-const CompilerInstance *Interpreter::getCompilerInstance() const {
- return IncrParser->getCI();
-}
-
-llvm::Expected<Transaction &> Interpreter::Parse(llvm::StringRef Code) {
- return IncrParser->Parse(Code);
-}
-
-llvm::Error Interpreter::Execute(Transaction &T) {
- assert(T.TheModule);
- if (!IncrExecutor) {
- llvm::Error Err = llvm::Error::success();
- IncrExecutor = std::make_unique<IncrementalExecutor>(*TSCtx, Err);
- if (Err)
- return Err;
- }
- // FIXME: Add a callback to retain the llvm::Module once the JIT is done.
- if (auto Err = IncrExecutor->addModule(std::move(T.TheModule)))
- return Err;
-
- if (auto Err = IncrExecutor->runCtors())
- return Err;
-
- return llvm::Error::success();
-}
diff --git a/clang/test/CMakeLists.txt b/clang/test/CMakeLists.txt
index 8e3460f75c37..f87b32a97fa6 100644
--- a/clang/test/CMakeLists.txt
+++ b/clang/test/CMakeLists.txt
@@ -68,7 +68,6 @@ list(APPEND CLANG_TEST_DEPS
clang-import-test
clang-rename
clang-refactor
- clang-repl
clang-
diff
clang-scan-deps
diagtool
diff --git a/clang/test/Interpreter/execute.cpp b/clang/test/Interpreter/execute.cpp
deleted file mode 100644
index 81ab57e955cf..000000000000
--- a/clang/test/Interpreter/execute.cpp
+++ /dev/null
@@ -1,14 +0,0 @@
-// RUN: cat %s | clang-repl | FileCheck %s
-// REQUIRES: host-supports-jit
-
-extern "C" int printf(const char *, ...);
-int i = 42;
-auto r1 = printf("i = %d\n", i);
-// CHECK: i = 42
-
-struct S { float f = 1.0; S *m = nullptr;} s;
-
-auto r2 = printf("S[f=%f, m=0x%llx]\n", s.f, reinterpret_cast<unsigned long long>(s.m));
-// CHECK-NEXT: S[f=1.000000, m=0x0]
-
-quit
diff --git a/clang/test/Interpreter/sanity.c b/clang/test/Interpreter/sanity.c
deleted file mode 100644
index f77faaf6748b..000000000000
--- a/clang/test/Interpreter/sanity.c
+++ /dev/null
@@ -1,18 +0,0 @@
-// RUN: cat %s | \
-// RUN: clang-repl -Xcc -fno-color-diagnostics -Xcc -Xclang -Xcc -ast-dump \
-// RUN: -Xcc -Xclang -Xcc -ast-dump-filter -Xcc -Xclang -Xcc Test 2>&1| \
-// RUN: FileCheck %s
-
-int TestVar = 12;
-// CHECK: Dumping TestVar:
-// CHECK-NEXT: VarDecl [[var_ptr:0x[0-9a-f]+]] <{{.*}} TestVar 'int' cinit
-// CHECK-NEXT: IntegerLiteral {{.*}} 'int' 12
-
-void TestFunc() { ++TestVar; }
-// CHECK: Dumping TestFunc:
-// CHECK-NEXT: FunctionDecl {{.*}} TestFunc 'void ()'
-// CHECK-NEXT: CompoundStmt{{.*}}
-// CHECK-NEXT: UnaryOperator{{.*}} 'int' lvalue prefix '++'
-// CHECK-NEXT: DeclRefExpr{{.*}} 'int' lvalue Var [[var_ptr]] 'TestVar' 'int'
-
-quit
diff --git a/clang/test/lit.cfg.py b/clang/test/lit.cfg.py
index c872b6aab847..7411e8716943 100644
--- a/clang/test/lit.cfg.py
+++ b/clang/test/lit.cfg.py
@@ -63,7 +63,7 @@
tool_dirs = [config.clang_tools_dir, config.llvm_tools_dir]
tools = [
- 'apinotes-test', 'c-index-test', 'clang-
diff ', 'clang-format', 'clang-repl',
+ 'apinotes-test', 'c-index-test', 'clang-
diff ', 'clang-format',
'clang-tblgen', 'opt', 'llvm-ifs', 'yaml2obj',
ToolSubst('%clang_extdef_map', command=FindTool(
'clang-extdef-mapping'), unresolved='ignore'),
@@ -73,28 +73,6 @@
config.available_features.add('examples')
tools.append('clang-interpreter')
-def have_host_jit_support():
- clang_repl_exe = lit.util.which('clang-repl', config.clang_tools_dir)
-
- if not clang_repl_exe:
- print('clang-repl not found')
- return False
-
- try:
- clang_repl_cmd = subprocess.Popen(
- [clang_repl_exe, '--host-supports-jit'], stdout=subprocess.PIPE)
- except OSError:
- print('could not exec clang-repl')
- return False
-
- clang_repl_out = clang_repl_cmd.stdout.read().decode('ascii')
- clang_repl_cmd.wait()
-
- return 'true' in clang_repl_out
-
-if have_host_jit_support():
- config.available_features.add('host-supports-jit')
-
if config.clang_staticanalyzer:
config.available_features.add('staticanalyzer')
tools.append('clang-check')
diff --git a/clang/tools/CMakeLists.txt b/clang/tools/CMakeLists.txt
index 63fe79eccf73..32359178066c 100644
--- a/clang/tools/CMakeLists.txt
+++ b/clang/tools/CMakeLists.txt
@@ -11,7 +11,6 @@ add_clang_subdirectory(clang-import-test)
add_clang_subdirectory(clang-offload-bundler)
add_clang_subdirectory(clang-offload-wrapper)
add_clang_subdirectory(clang-scan-deps)
-add_clang_subdirectory(clang-repl)
add_clang_subdirectory(c-index-test)
diff --git a/clang/tools/clang-repl/CMakeLists.txt b/clang/tools/clang-repl/CMakeLists.txt
deleted file mode 100644
index 558ac4837f9a..000000000000
--- a/clang/tools/clang-repl/CMakeLists.txt
+++ /dev/null
@@ -1,19 +0,0 @@
-set( LLVM_LINK_COMPONENTS
- ${LLVM_TARGETS_TO_BUILD}
- Option
- Support
- )
-
-add_clang_executable(clang-repl
- EXCLUDE_FROM_ALL
- ClangRepl.cpp
- )
-
-target_link_libraries(clang-repl PUBLIC
- clangInterpreter
- clangTooling
- LLVMLineEditor
- )
-
-install(TARGETS clang-repl
- RUNTIME DESTINATION bin)
diff --git a/clang/tools/clang-repl/ClangRepl.cpp b/clang/tools/clang-repl/ClangRepl.cpp
deleted file mode 100644
index b5b5bf6e0c6b..000000000000
--- a/clang/tools/clang-repl/ClangRepl.cpp
+++ /dev/null
@@ -1,98 +0,0 @@
-//===--- tools/clang-repl/ClangRepl.cpp - clang-repl - the Clang REPL -----===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// This file implements a REPL tool on top of clang.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Basic/Diagnostic.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/FrontendDiagnostic.h"
-#include "clang/Interpreter/Interpreter.h"
-
-#include "llvm/ExecutionEngine/Orc/LLJIT.h"
-#include "llvm/LineEditor/LineEditor.h"
-#include "llvm/Support/CommandLine.h"
-#include "llvm/Support/ManagedStatic.h" // llvm_shutdown
-#include "llvm/Support/Signals.h"
-#include "llvm/Support/TargetSelect.h" // llvm::Initialize*
-
-static llvm::cl::list<std::string>
- ClangArgs("Xcc", llvm::cl::ZeroOrMore,
- llvm::cl::desc("Argument to pass to the CompilerInvocation"),
- llvm::cl::CommaSeparated);
-static llvm::cl::opt<bool> OptHostSupportsJit("host-supports-jit",
- llvm::cl::Hidden);
-
-static void LLVMErrorHandler(void *UserData, const std::string &Message,
- bool GenCrashDiag) {
- auto &Diags = *static_cast<clang::DiagnosticsEngine *>(UserData);
-
- Diags.Report(clang::diag::err_fe_error_backend) << Message;
-
- // Run the interrupt handlers to make sure any special cleanups get done, in
- // particular that we remove files registered with RemoveFileOnSignal.
- llvm::sys::RunInterruptHandlers();
-
- // We cannot recover from llvm errors. When reporting a fatal error, exit
- // with status 70 to generate crash diagnostics. For BSD systems this is
- // defined as an internal software error. Otherwise, exit with status 1.
-
- exit(GenCrashDiag ? 70 : 1);
-}
-
-llvm::ExitOnError ExitOnErr;
-int main(int argc, const char **argv) {
- ExitOnErr.setBanner("clang-repl: ");
- llvm::cl::ParseCommandLineOptions(argc, argv);
-
- std::vector<const char *> ClangArgv(ClangArgs.size());
- std::transform(ClangArgs.begin(), ClangArgs.end(), ClangArgv.begin(),
- [](const std::string &s) -> const char * { return s.data(); });
- llvm::InitializeNativeTarget();
- llvm::InitializeNativeTargetAsmPrinter();
-
- if (OptHostSupportsJit) {
- auto J = llvm::orc::LLJITBuilder().create();
- if (J)
- llvm::outs() << "true\n";
- else {
- llvm::consumeError(J.takeError());
- llvm::outs() << "false\n";
- }
- return 0;
- }
-
- // FIXME: Investigate if we could use runToolOnCodeWithArgs from tooling. It
- // can replace the boilerplate code for creation of the compiler instance.
- auto CI = ExitOnErr(clang::IncrementalCompilerBuilder::create(ClangArgv));
-
- // Set an error handler, so that any LLVM backend diagnostics go through our
- // error handler.
- llvm::install_fatal_error_handler(LLVMErrorHandler,
- static_cast<void *>(&CI->getDiagnostics()));
-
- auto Interp = ExitOnErr(clang::Interpreter::create(std::move(CI)));
- llvm::LineEditor LE("clang-repl");
- // FIXME: Add LE.setListCompleter
- while (llvm::Optional<std::string> Line = LE.readLine()) {
- if (*Line == "quit")
- break;
- if (auto Err = Interp->ParseAndExecute(*Line))
- llvm::logAllUnhandledErrors(std::move(Err), llvm::errs(), "error: ");
- }
-
- // Our error handler depends on the Diagnostics object, which we're
- // potentially about to delete. Uninstall the handler now so that any
- // later errors use the default handling behavior instead.
- llvm::remove_fatal_error_handler();
-
- llvm::llvm_shutdown();
-
- return 0;
-}
diff --git a/clang/unittests/CMakeLists.txt b/clang/unittests/CMakeLists.txt
index 51fe5de9ce64..4e0873955700 100644
--- a/clang/unittests/CMakeLists.txt
+++ b/clang/unittests/CMakeLists.txt
@@ -35,7 +35,6 @@ add_subdirectory(Frontend)
add_subdirectory(Rewrite)
add_subdirectory(Sema)
add_subdirectory(CodeGen)
-add_subdirectory(Interpreter)
# FIXME: libclang unit tests are disabled on Windows due
# to failures, mostly in libclang.VirtualFileOverlay_*.
if(NOT WIN32 AND CLANG_TOOL_LIBCLANG_BUILD)
diff --git a/clang/unittests/CodeGen/CMakeLists.txt b/clang/unittests/CodeGen/CMakeLists.txt
index a9a7b7a1cbaa..3fe547a65086 100644
--- a/clang/unittests/CodeGen/CMakeLists.txt
+++ b/clang/unittests/CodeGen/CMakeLists.txt
@@ -6,6 +6,7 @@ set(LLVM_LINK_COMPONENTS
add_clang_unittest(ClangCodeGenTests
BufferSourceTest.cpp
CodeGenExternalTest.cpp
+ IncrementalProcessingTest.cpp
TBAAMetadataTest.cpp
CheckTargetFeaturesTest.cpp
)
@@ -16,7 +17,6 @@ clang_target_link_libraries(ClangCodeGenTests
clangBasic
clangCodeGen
clangFrontend
- clangInterpreter
clangLex
clangParse
clangSerialization
diff --git a/clang/unittests/CodeGen/IncrementalProcessingTest.cpp b/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
new file mode 100644
index 000000000000..fed8ecd59f35
--- /dev/null
+++ b/clang/unittests/CodeGen/IncrementalProcessingTest.cpp
@@ -0,0 +1,155 @@
+//=== unittests/CodeGen/IncrementalProcessingTest.cpp - IncrementalCodeGen ===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "TestCompiler.h"
+
+#include "clang/AST/ASTConsumer.h"
+#include "clang/AST/ASTContext.h"
+#include "clang/AST/RecursiveASTVisitor.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/CodeGen/ModuleBuilder.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Lex/Preprocessor.h"
+#include "clang/Parse/Parser.h"
+#include "clang/Sema/Sema.h"
+#include "llvm/ADT/Triple.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Host.h"
+#include "llvm/Support/MemoryBuffer.h"
+#include "gtest/gtest.h"
+
+#include <memory>
+
+using namespace llvm;
+using namespace clang;
+
+namespace {
+
+// Incremental processing produces several modules, all using the same "main
+// file". Make sure CodeGen can cope with that, e.g. for static initializers.
+const char TestProgram1[] =
+ "extern \"C\" int funcForProg1() { return 17; }\n"
+ "struct EmitCXXGlobalInitFunc1 {\n"
+ " EmitCXXGlobalInitFunc1() {}\n"
+ "} test1;";
+
+const char TestProgram2[] =
+ "extern \"C\" int funcForProg2() { return 42; }\n"
+ "struct EmitCXXGlobalInitFunc2 {\n"
+ " EmitCXXGlobalInitFunc2() {}\n"
+ "} test2;";
+
+
+/// An incremental version of ParseAST().
+static std::unique_ptr<llvm::Module>
+IncrementalParseAST(CompilerInstance& CI, Parser& P,
+ CodeGenerator& CG, const char* code) {
+ static int counter = 0;
+ struct IncreaseCounterOnRet {
+ ~IncreaseCounterOnRet() {
+ ++counter;
+ }
+ } ICOR;
+
+ Sema& S = CI.getSema();
+ clang::SourceManager &SM = S.getSourceManager();
+ if (!code) {
+ // Main file
+ SM.setMainFileID(SM.createFileID(
+ llvm::MemoryBuffer::getMemBuffer(" "), clang::SrcMgr::C_User));
+
+ S.getPreprocessor().EnterMainSourceFile();
+ P.Initialize();
+ } else {
+ FileID FID = SM.createFileID(
+ llvm::MemoryBuffer::getMemBuffer(code), clang::SrcMgr::C_User);
+ SourceLocation MainStartLoc = SM.getLocForStartOfFile(SM.getMainFileID());
+ SourceLocation InclLoc = MainStartLoc.getLocWithOffset(counter);
+ S.getPreprocessor().EnterSourceFile(FID, 0, InclLoc);
+ }
+
+ ExternalASTSource *External = S.getASTContext().getExternalSource();
+ if (External)
+ External->StartTranslationUnit(&CG);
+
+ Parser::DeclGroupPtrTy ADecl;
+ for (bool AtEOF = P.ParseFirstTopLevelDecl(ADecl); !AtEOF;
+ AtEOF = P.ParseTopLevelDecl(ADecl)) {
+ // If we got a null return and something *was* parsed, ignore it. This
+ // is due to a top-level semicolon, an action override, or a parse error
+ // skipping something.
+ if (ADecl && !CG.HandleTopLevelDecl(ADecl.get()))
+ return nullptr;
+ }
+
+ // Process any TopLevelDecls generated by #pragma weak.
+ for (Decl *D : S.WeakTopLevelDecls())
+ CG.HandleTopLevelDecl(DeclGroupRef(D));
+
+ CG.HandleTranslationUnit(S.getASTContext());
+
+ std::unique_ptr<llvm::Module> M(CG.ReleaseModule());
+ // Switch to next module.
+ CG.StartModule("incremental-module-" + std::to_string(counter),
+ M->getContext());
+ return M;
+}
+
+const Function* getGlobalInit(llvm::Module& M) {
+ for (const auto& Func: M)
+ if (Func.hasName() && Func.getName().startswith("_GLOBAL__sub_I_"))
+ return &Func;
+
+ return nullptr;
+}
+
+TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TestCompiler Compiler(LO);
+ clang::CompilerInstance &CI = Compiler.compiler;
+ CI.getPreprocessor().enableIncrementalProcessing();
+ CI.setASTConsumer(std::move(Compiler.CG));
+ clang::CodeGenerator& CG =
+ static_cast<clang::CodeGenerator&>(CI.getASTConsumer());
+ CI.createSema(clang::TU_Prefix, nullptr);
+
+ Sema& S = CI.getSema();
+
+ std::unique_ptr<Parser> ParseOP(new Parser(S.getPreprocessor(), S,
+ /*SkipFunctionBodies*/ false));
+ Parser &P = *ParseOP.get();
+
+ std::array<std::unique_ptr<llvm::Module>, 3> M;
+ M[0] = IncrementalParseAST(CI, P, CG, nullptr);
+ ASSERT_TRUE(M[0]);
+
+ M[1] = IncrementalParseAST(CI, P, CG, TestProgram1);
+ ASSERT_TRUE(M[1]);
+ ASSERT_TRUE(M[1]->getFunction("funcForProg1"));
+
+ M[2] = IncrementalParseAST(CI, P, CG, TestProgram2);
+ ASSERT_TRUE(M[2]);
+ ASSERT_TRUE(M[2]->getFunction("funcForProg2"));
+ // First code should not end up in second module:
+ ASSERT_FALSE(M[2]->getFunction("funcForProg1"));
+
+ // Make sure global inits exist and are unique:
+ const Function* GlobalInit1 = getGlobalInit(*M[1]);
+ ASSERT_TRUE(GlobalInit1);
+
+ const Function* GlobalInit2 = getGlobalInit(*M[2]);
+ ASSERT_TRUE(GlobalInit2);
+
+ ASSERT_FALSE(GlobalInit1->getName() == GlobalInit2->getName());
+
+}
+
+} // end anonymous namespace
diff --git a/clang/unittests/Interpreter/CMakeLists.txt b/clang/unittests/Interpreter/CMakeLists.txt
deleted file mode 100644
index b0def94382a6..000000000000
--- a/clang/unittests/Interpreter/CMakeLists.txt
+++ /dev/null
@@ -1,11 +0,0 @@
-set(LLVM_LINK_COMPONENTS
- )
-
-add_clang_unittest(ClangReplInterpreterTests
- IncrementalProcessingTest.cpp
- InterpreterTest.cpp
- )
-target_link_libraries(ClangReplInterpreterTests PUBLIC
- clangInterpreter
- clangFrontend
- )
diff --git a/clang/unittests/Interpreter/IncrementalProcessingTest.cpp b/clang/unittests/Interpreter/IncrementalProcessingTest.cpp
deleted file mode 100644
index 7d58d9837b8f..000000000000
--- a/clang/unittests/Interpreter/IncrementalProcessingTest.cpp
+++ /dev/null
@@ -1,80 +0,0 @@
-//=== unittests/CodeGen/IncrementalProcessingTest.cpp - IncrementalCodeGen ===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/AST/ASTConsumer.h"
-#include "clang/AST/ASTContext.h"
-#include "clang/AST/RecursiveASTVisitor.h"
-#include "clang/Basic/TargetInfo.h"
-#include "clang/CodeGen/ModuleBuilder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Interpreter/Interpreter.h"
-#include "clang/Lex/Preprocessor.h"
-#include "clang/Parse/Parser.h"
-#include "clang/Sema/Sema.h"
-#include "llvm/ADT/Triple.h"
-#include "llvm/IR/LLVMContext.h"
-#include "llvm/IR/Module.h"
-#include "llvm/Support/Host.h"
-#include "llvm/Support/MemoryBuffer.h"
-#include "gtest/gtest.h"
-
-#include <memory>
-
-using namespace llvm;
-using namespace clang;
-
-namespace {
-
-// Incremental processing produces several modules, all using the same "main
-// file". Make sure CodeGen can cope with that, e.g. for static initializers.
-const char TestProgram1[] = "extern \"C\" int funcForProg1() { return 17; }\n"
- "struct EmitCXXGlobalInitFunc1 {\n"
- " EmitCXXGlobalInitFunc1() {}\n"
- "} test1;";
-
-const char TestProgram2[] = "extern \"C\" int funcForProg2() { return 42; }\n"
- "struct EmitCXXGlobalInitFunc2 {\n"
- " EmitCXXGlobalInitFunc2() {}\n"
- "} test2;";
-
-const Function *getGlobalInit(llvm::Module *M) {
- for (const auto &Func : *M)
- if (Func.hasName() && Func.getName().startswith("_GLOBAL__sub_I_"))
- return &Func;
-
- return nullptr;
-}
-
-TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
- std::vector<const char *> ClangArgv = {"-Xclang", "-emit-llvm-only"};
- auto CI = llvm::cantFail(IncrementalCompilerBuilder::create(ClangArgv));
- auto Interp = llvm::cantFail(Interpreter::create(std::move(CI)));
-
- std::array<clang::Transaction *, 2> Transactions;
-
- Transactions[0] = &llvm::cantFail(Interp->Parse(TestProgram1));
- ASSERT_TRUE(Transactions[0]->TheModule);
- ASSERT_TRUE(Transactions[0]->TheModule->getFunction("funcForProg1"));
-
- Transactions[1] = &llvm::cantFail(Interp->Parse(TestProgram2));
- ASSERT_TRUE(Transactions[1]->TheModule);
- ASSERT_TRUE(Transactions[1]->TheModule->getFunction("funcForProg2"));
- // First code should not end up in second module:
- ASSERT_FALSE(Transactions[1]->TheModule->getFunction("funcForProg1"));
-
- // Make sure global inits exist and are unique:
- const Function *GlobalInit1 = getGlobalInit(Transactions[0]->TheModule.get());
- ASSERT_TRUE(GlobalInit1);
-
- const Function *GlobalInit2 = getGlobalInit(Transactions[1]->TheModule.get());
- ASSERT_TRUE(GlobalInit2);
-
- ASSERT_FALSE(GlobalInit1->getName() == GlobalInit2->getName());
-}
-
-} // end anonymous namespace
diff --git a/clang/unittests/Interpreter/InterpreterTest.cpp b/clang/unittests/Interpreter/InterpreterTest.cpp
deleted file mode 100644
index 984255c0a229..000000000000
--- a/clang/unittests/Interpreter/InterpreterTest.cpp
+++ /dev/null
@@ -1,122 +0,0 @@
-//===- unittests/Interpreter/InterpreterTest.cpp --- Interpreter tests ----===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-//
-// Unit tests for Clang's Interpreter library.
-//
-//===----------------------------------------------------------------------===//
-
-#include "clang/Interpreter/Interpreter.h"
-
-#include "clang/AST/Decl.h"
-#include "clang/AST/DeclGroup.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Frontend/TextDiagnosticPrinter.h"
-
-#include "llvm/ADT/ArrayRef.h"
-
-#include "gmock/gmock.h"
-#include "gtest/gtest.h"
-
-using namespace clang;
-
-namespace {
-using Args = std::vector<const char *>;
-static std::unique_ptr<Interpreter>
-createInterpreter(const Args &ExtraArgs = {},
- DiagnosticConsumer *Client = nullptr) {
- Args ClangArgs = {"-Xclang", "-emit-llvm-only"};
- ClangArgs.insert(ClangArgs.end(), ExtraArgs.begin(), ExtraArgs.end());
- auto CI = cantFail(clang::IncrementalCompilerBuilder::create(ClangArgs));
- if (Client)
- CI->getDiagnostics().setClient(Client, /*ShouldOwnClient=*/false);
- return cantFail(clang::Interpreter::create(std::move(CI)));
-}
-
-TEST(InterpreterTest, Sanity) {
- std::unique_ptr<Interpreter> Interp = createInterpreter();
- Transaction &R1(cantFail(Interp->Parse("void g(); void g() {}")));
- EXPECT_EQ(2U, R1.Decls.size());
-
- Transaction &R2(cantFail(Interp->Parse("int i;")));
- EXPECT_EQ(1U, R2.Decls.size());
-}
-
-static std::string DeclToString(DeclGroupRef DGR) {
- return llvm::cast<NamedDecl>(DGR.getSingleDecl())->getQualifiedNameAsString();
-}
-
-TEST(InterpreterTest, IncrementalInputTopLevelDecls) {
- std::unique_ptr<Interpreter> Interp = createInterpreter();
- auto R1OrErr = Interp->Parse("int var1 = 42; int f() { return var1; }");
- // gtest doesn't expand into explicit bool conversions.
- EXPECT_TRUE(!!R1OrErr);
- auto R1 = R1OrErr->Decls;
- EXPECT_EQ(2U, R1.size());
- EXPECT_EQ("var1", DeclToString(R1[0]));
- EXPECT_EQ("f", DeclToString(R1[1]));
-
- auto R2OrErr = Interp->Parse("int var2 = f();");
- EXPECT_TRUE(!!R2OrErr);
- auto R2 = R2OrErr->Decls;
- EXPECT_EQ(1U, R2.size());
- EXPECT_EQ("var2", DeclToString(R2[0]));
-}
-
-TEST(InterpreterTest, Errors) {
- Args ExtraArgs = {"-Xclang", "-diagnostic-log-file", "-Xclang", "-"};
-
- // Create the diagnostic engine with unowned consumer.
- std::string DiagnosticOutput;
- llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
- auto DiagPrinter = std::make_unique<TextDiagnosticPrinter>(
- DiagnosticsOS, new DiagnosticOptions());
-
- auto Interp = createInterpreter(ExtraArgs, DiagPrinter.get());
- auto Err = Interp->Parse("intentional_error v1 = 42; ").takeError();
- using ::testing::HasSubstr;
- EXPECT_THAT(DiagnosticsOS.str(),
- HasSubstr("error: unknown type name 'intentional_error'"));
- EXPECT_EQ("Parsing failed.", llvm::toString(std::move(Err)));
-
-#ifdef GTEST_HAS_DEATH_TEST
- EXPECT_DEATH((void)Interp->Parse("int var1 = 42;"), "");
-#endif
-}
-
-// Here we test whether the user can mix declarations and statements. The
-// interpreter should be smart enough to recognize the declarations from the
-// statements and wrap the latter into a declaration, producing valid code.
-TEST(InterpreterTest, DeclsAndStatements) {
- Args ExtraArgs = {"-Xclang", "-diagnostic-log-file", "-Xclang", "-"};
-
- // Create the diagnostic engine with unowned consumer.
- std::string DiagnosticOutput;
- llvm::raw_string_ostream DiagnosticsOS(DiagnosticOutput);
- auto DiagPrinter = std::make_unique<TextDiagnosticPrinter>(
- DiagnosticsOS, new DiagnosticOptions());
-
- auto Interp = createInterpreter(ExtraArgs, DiagPrinter.get());
- auto R1OrErr = Interp->Parse(
- "int var1 = 42; extern \"C\" int printf(const char*, ...);");
- // gtest doesn't expand into explicit bool conversions.
- EXPECT_TRUE(!!R1OrErr);
-
- auto R1 = R1OrErr->Decls;
- EXPECT_EQ(2U, R1.size());
-
- // FIXME: Add support for wrapping and running statements.
- auto R2OrErr = Interp->Parse("var1++; printf(\"var1 value %d\\n\", var1);");
- EXPECT_FALSE(!!R2OrErr);
- using ::testing::HasSubstr;
- EXPECT_THAT(DiagnosticsOS.str(),
- HasSubstr("error: unknown type name 'var1'"));
- auto Err = R2OrErr.takeError();
- EXPECT_EQ("Parsing failed.", llvm::toString(std::move(Err)));
-}
-
-} // end anonymous namespace
More information about the cfe-commits
mailing list