//
//===----------------------------------------------------------------------===//
-#include "clang/AST/ASTConsumer.h"
+#include "TestCompiler.h"
+
#include "clang/AST/ASTContext.h"
#include "clang/AST/RecursiveASTVisitor.h"
#include "clang/Basic/TargetInfo.h"
namespace {
-// Emitting constructors for global objects involves looking
-// at the source file name. This makes sure that we don't crash
-// if the source file is a memory buffer.
-const char TestProgram[] =
+TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
+ // Emitting constructors for global objects involves looking
+ // at the source file name. This makes sure that we don't crash
+ // if the source file is a memory buffer.
+ const char TestProgram[] =
"class EmitCXXGlobalInitFunc "
"{ "
"public: "
"}; "
"EmitCXXGlobalInitFunc test; ";
-TEST(BufferSourceTest, EmitCXXGlobalInitFunc) {
- LLVMContext Context;
- CompilerInstance compiler;
-
- compiler.createDiagnostics();
- compiler.getLangOpts().CPlusPlus = 1;
- compiler.getLangOpts().CPlusPlus11 = 1;
-
- compiler.getTargetOpts().Triple = llvm::Triple::normalize(
- llvm::sys::getProcessTriple());
- compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
- compiler.getDiagnostics(),
- std::make_shared<clang::TargetOptions>(
- compiler.getTargetOpts())));
-
- compiler.createFileManager();
- compiler.createSourceManager(compiler.getFileManager());
- compiler.createPreprocessor(clang::TU_Prefix);
-
- compiler.createASTContext();
-
- compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
- CreateLLVMCodeGen(
- compiler.getDiagnostics(),
- "EmitCXXGlobalInitFuncTest",
- compiler.getHeaderSearchOpts(),
- compiler.getPreprocessorOpts(),
- compiler.getCodeGenOpts(),
- Context)));
-
- compiler.createSema(clang::TU_Prefix, nullptr);
-
- clang::SourceManager &sm = compiler.getSourceManager();
- sm.setMainFileID(sm.createFileID(
- llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TestCompiler Compiler(LO);
+ Compiler.init(TestProgram);
- clang::ParseAST(compiler.getSema(), false, false);
+ clang::ParseAST(Compiler.compiler.getSema(), false, false);
}
} // end anonymous namespace
//
//===----------------------------------------------------------------------===//
+#include "TestCompiler.h"
+
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/GlobalDecl.h"
}
TEST(CodeGenExternalTest, CodeGenExternalTest) {
- LLVMContext Context;
- CompilerInstance compiler;
-
- compiler.createDiagnostics();
- compiler.getLangOpts().CPlusPlus = 1;
- compiler.getLangOpts().CPlusPlus11 = 1;
-
- compiler.getTargetOpts().Triple = llvm::Triple::normalize(
- llvm::sys::getProcessTriple());
- compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
- compiler.getDiagnostics(),
- std::make_shared<clang::TargetOptions>(
- compiler.getTargetOpts())));
-
- compiler.createFileManager();
- compiler.createSourceManager(compiler.getFileManager());
- compiler.createPreprocessor(clang::TU_Prefix);
-
- compiler.createASTContext();
-
-
- compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(
- new MyASTConsumer(std::unique_ptr<CodeGenerator>(
- CreateLLVMCodeGen(compiler.getDiagnostics(),
- "MemoryTypesTest",
- compiler.getHeaderSearchOpts(),
- compiler.getPreprocessorOpts(),
- compiler.getCodeGenOpts(),
- Context)))));
-
- compiler.createSema(clang::TU_Prefix, nullptr);
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TestCompiler Compiler(LO);
+ auto CustomASTConsumer
+ = std::make_unique<MyASTConsumer>(std::move(Compiler.CG));
- clang::SourceManager &sm = compiler.getSourceManager();
- sm.setMainFileID(sm.createFileID(
- llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
+ Compiler.init(TestProgram, std::move(CustomASTConsumer));
- clang::ParseAST(compiler.getSema(), false, false);
+ clang::ParseAST(Compiler.compiler.getSema(), false, false);
- ASSERT_TRUE(test_codegen_fns_ran);
+ ASSERT_TRUE(test_codegen_fns_ran);
}
} // end anonymous namespace
//
//===----------------------------------------------------------------------===//
+#include "TestCompiler.h"
+
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/AST/RecursiveASTVisitor.h"
}
TEST(IncrementalProcessing, EmitCXXGlobalInitFunc) {
- LLVMContext Context;
- CompilerInstance compiler;
-
- compiler.createDiagnostics();
- compiler.getLangOpts().CPlusPlus = 1;
- compiler.getLangOpts().CPlusPlus11 = 1;
-
- compiler.getTargetOpts().Triple = llvm::Triple::normalize(
- llvm::sys::getProcessTriple());
- compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
- compiler.getDiagnostics(),
- std::make_shared<clang::TargetOptions>(
- compiler.getTargetOpts())));
-
- compiler.createFileManager();
- compiler.createSourceManager(compiler.getFileManager());
- compiler.createPreprocessor(clang::TU_Prefix);
- compiler.getPreprocessor().enableIncrementalProcessing();
-
- compiler.createASTContext();
-
- CodeGenerator* CG =
- CreateLLVMCodeGen(
- compiler.getDiagnostics(),
- "main-module",
- compiler.getHeaderSearchOpts(),
- compiler.getPreprocessorOpts(),
- compiler.getCodeGenOpts(),
- Context);
- compiler.setASTConsumer(std::unique_ptr<ASTConsumer>(CG));
- compiler.createSema(clang::TU_Prefix, nullptr);
- Sema& S = compiler.getSema();
+ 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(compiler, P, *CG, nullptr);
+ M[0] = IncrementalParseAST(CI, P, CG, nullptr);
ASSERT_TRUE(M[0]);
- M[1] = IncrementalParseAST(compiler, P, *CG, TestProgram1);
+ M[1] = IncrementalParseAST(CI, P, CG, TestProgram1);
ASSERT_TRUE(M[1]);
ASSERT_TRUE(M[1]->getFunction("funcForProg1"));
- M[2] = IncrementalParseAST(compiler, P, *CG, TestProgram2);
+ 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:
//===----------------------------------------------------------------------===//
#include "IRMatchers.h"
+#include "TestCompiler.h"
#include "clang/AST/ASTConsumer.h"
#include "clang/AST/ASTContext.h"
#include "clang/Basic/SourceManager.h"
#include "clang/Basic/TargetInfo.h"
-#include "clang/CodeGen/ModuleBuilder.h"
-#include "clang/Frontend/CompilerInstance.h"
-#include "clang/Parse/ParseAST.h"
-#include "llvm/ADT/Triple.h"
#include "llvm/IR/Constants.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>
namespace {
-struct TestCompiler {
- LLVMContext Context;
- clang::CompilerInstance compiler;
- clang::CodeGenerator *CG = nullptr;
- llvm::Module *M = nullptr;
- unsigned PtrSize = 0;
-
- void init(const char *TestProgram) {
- compiler.createDiagnostics();
- compiler.getCodeGenOpts().StructPathTBAA = 1;
- compiler.getCodeGenOpts().OptimizationLevel = 1;
-
- std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
- llvm::Triple Tr(TrStr);
- Tr.setOS(Triple::Linux);
- Tr.setVendor(Triple::VendorType::UnknownVendor);
- Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);
- compiler.getTargetOpts().Triple = Tr.getTriple();
- compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
- compiler.getDiagnostics(),
- std::make_shared<clang::TargetOptions>(compiler.getTargetOpts())));
-
- const clang::TargetInfo &TInfo = compiler.getTarget();
- PtrSize = TInfo.getPointerWidth(0) / 8;
-
- compiler.createFileManager();
- compiler.createSourceManager(compiler.getFileManager());
- compiler.createPreprocessor(clang::TU_Prefix);
-
- compiler.createASTContext();
-
- CG = CreateLLVMCodeGen(
- compiler.getDiagnostics(),
- "main-module",
- compiler.getHeaderSearchOpts(),
- compiler.getPreprocessorOpts(),
- compiler.getCodeGenOpts(),
- Context);
- compiler.setASTConsumer(std::unique_ptr<clang::ASTConsumer>(CG));
-
- compiler.createSema(clang::TU_Prefix, nullptr);
-
- clang::SourceManager &sm = compiler.getSourceManager();
- sm.setMainFileID(sm.createFileID(
- llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
- }
-
- const BasicBlock *compile() {
- clang::ParseAST(compiler.getSema(), false, false);
- M = CG->GetModule();
-
- // Do not expect more than one function definition.
- auto FuncPtr = M->begin();
- for (; FuncPtr != M->end(); ++FuncPtr)
- if (!FuncPtr->isDeclaration())
- break;
- assert(FuncPtr != M->end());
- const llvm::Function &Func = *FuncPtr;
- ++FuncPtr;
- for (; FuncPtr != M->end(); ++FuncPtr)
- if (!FuncPtr->isDeclaration())
- break;
- assert(FuncPtr == M->end());
-
- // The function must consist of single basic block.
- auto BBPtr = Func.begin();
- assert(Func.begin() != Func.end());
- const BasicBlock &BB = *BBPtr;
- ++BBPtr;
- assert(BBPtr == Func.end());
-
- return &BB;
+struct TBAATestCompiler : public TestCompiler {
+ TBAATestCompiler(clang::LangOptions LO, clang::CodeGenOptions CGO)
+ : TestCompiler(LO, CGO) {}
+ static clang::CodeGenOptions getCommonCodeGenOpts() {
+ clang::CodeGenOptions CGOpts;
+ CGOpts.StructPathTBAA = 1;
+ CGOpts.OptimizationLevel = 1;
+ return CGOpts;
}
};
-
auto OmnipotentCharC = MMTuple(
MMString("omnipotent char"),
MMTuple(
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().C11 = 1;
+ clang::LangOptions LO;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().C11 = 1;
+ clang::LangOptions LO;
+ LO.C11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().C11 = 1;
+ clang::LangOptions LO;
+ LO.C11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().C11 = 1;
+ clang::LangOptions LO;
+ LO.C11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().C11 = 1;
+ clang::LangOptions LO;
+ LO.C11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
}
)**";
- TestCompiler Compiler;
- Compiler.compiler.getLangOpts().CPlusPlus = 1;
- Compiler.compiler.getLangOpts().CPlusPlus11 = 1;
+ clang::LangOptions LO;
+ LO.CPlusPlus = 1;
+ LO.CPlusPlus11 = 1;
+ TBAATestCompiler Compiler(LO, TBAATestCompiler::getCommonCodeGenOpts());
Compiler.init(TestProgram);
const BasicBlock *BB = Compiler.compile();
--- /dev/null
+//=== unittests/CodeGen/TestCompiler.h - Match on the LLVM IR ---*- 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
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef CLANG_UNITTESTS_CODEGEN_TESTCOMPILER_H
+#define CLANG_UNITTESTS_CODEGEN_TESTCOMPILER_H
+
+
+#include "clang/AST/ASTConsumer.h"
+#include "clang/Basic/TargetInfo.h"
+#include "clang/Basic/TargetOptions.h"
+#include "clang/CodeGen/ModuleBuilder.h"
+#include "clang/Frontend/CompilerInstance.h"
+#include "clang/Parse/ParseAST.h"
+
+#include "llvm/IR/Constants.h"
+#include "llvm/IR/LLVMContext.h"
+#include "llvm/IR/Module.h"
+#include "llvm/Support/Host.h"
+
+namespace llvm {
+
+struct TestCompiler {
+ LLVMContext Context;
+ clang::CompilerInstance compiler;
+ std::unique_ptr<clang::CodeGenerator> CG;
+ llvm::Module *M = nullptr;
+ unsigned PtrSize = 0;
+
+ TestCompiler(clang::LangOptions LO,
+ clang::CodeGenOptions CGO = clang::CodeGenOptions()) {
+ compiler.getLangOpts() = LO;
+ compiler.getCodeGenOpts() = CGO;
+ compiler.createDiagnostics();
+
+ std::string TrStr = llvm::Triple::normalize(llvm::sys::getProcessTriple());
+ llvm::Triple Tr(TrStr);
+ Tr.setOS(Triple::Linux);
+ Tr.setVendor(Triple::VendorType::UnknownVendor);
+ Tr.setEnvironment(Triple::EnvironmentType::UnknownEnvironment);
+ compiler.getTargetOpts().Triple = Tr.getTriple();
+ compiler.setTarget(clang::TargetInfo::CreateTargetInfo(
+ compiler.getDiagnostics(),
+ std::make_shared<clang::TargetOptions>(compiler.getTargetOpts())));
+
+ const clang::TargetInfo &TInfo = compiler.getTarget();
+ PtrSize = TInfo.getPointerWidth(0) / 8;
+
+ compiler.createFileManager();
+ compiler.createSourceManager(compiler.getFileManager());
+ compiler.createPreprocessor(clang::TU_Prefix);
+
+ compiler.createASTContext();
+
+ CG.reset(CreateLLVMCodeGen(compiler.getDiagnostics(),
+ "main-module",
+ compiler.getHeaderSearchOpts(),
+ compiler.getPreprocessorOpts(),
+ compiler.getCodeGenOpts(),
+ Context));
+ }
+
+ void init(const char *TestProgram,
+ std::unique_ptr<clang::ASTConsumer> Consumer = nullptr) {
+ if (!Consumer)
+ Consumer = std::move(CG);
+
+ compiler.setASTConsumer(std::move(Consumer));
+
+ compiler.createSema(clang::TU_Prefix, nullptr);
+
+ clang::SourceManager &sm = compiler.getSourceManager();
+ sm.setMainFileID(sm.createFileID(
+ llvm::MemoryBuffer::getMemBuffer(TestProgram), clang::SrcMgr::C_User));
+ }
+
+ const BasicBlock *compile() {
+ clang::ParseAST(compiler.getSema(), false, false);
+ M =
+ static_cast<clang::CodeGenerator&>(compiler.getASTConsumer()).GetModule();
+
+ // Do not expect more than one function definition.
+ auto FuncPtr = M->begin();
+ for (; FuncPtr != M->end(); ++FuncPtr)
+ if (!FuncPtr->isDeclaration())
+ break;
+ assert(FuncPtr != M->end());
+ const llvm::Function &Func = *FuncPtr;
+ ++FuncPtr;
+ for (; FuncPtr != M->end(); ++FuncPtr)
+ if (!FuncPtr->isDeclaration())
+ break;
+ assert(FuncPtr == M->end());
+
+ // The function must consist of single basic block.
+ auto BBPtr = Func.begin();
+ assert(Func.begin() != Func.end());
+ const BasicBlock &BB = *BBPtr;
+ ++BBPtr;
+ assert(BBPtr == Func.end());
+
+ return &BB;
+ }
+};
+
+} // namespace llvm
+#endif // CLANG_UNITTESTS_CODEGEN_TESTCOMPILER_H