| //===- unittests/Frontend/FrontendActionTest.cpp FrontendAction 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 |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #include "flang/Frontend/CompilerInstance.h" |
| #include "flang/Frontend/CompilerInvocation.h" |
| #include "flang/Frontend/FrontendOptions.h" |
| #include "flang/FrontendTool/Utils.h" |
| #include "llvm/Support/FileSystem.h" |
| #include "llvm/Support/TargetSelect.h" |
| #include "llvm/Support/raw_ostream.h" |
| #include "llvm/TargetParser/Host.h" |
| #include "llvm/TargetParser/Triple.h" |
| |
| #include "gtest/gtest.h" |
| |
| using namespace Fortran::frontend; |
| |
| namespace { |
| |
| class FrontendActionTest : public ::testing::Test { |
| protected: |
| // AllSources (which is used to manage files inside every compiler |
| // instance), works with paths. So we need a filename and a path for the |
| // input file. |
| // TODO: We could use `-` for inputFilePath, but then we'd need a way to |
| // write to stdin that's then read by AllSources. Ideally, AllSources should |
| // be capable of reading from any stream. |
| std::string inputFileName; |
| std::string inputFilePath; |
| // The output stream for the input file. Use this to populate the input. |
| std::unique_ptr<llvm::raw_fd_ostream> inputFileOs; |
| |
| std::error_code ec; |
| |
| CompilerInstance compInst; |
| std::shared_ptr<CompilerInvocation> invoc; |
| |
| void SetUp() override { |
| // Generate a unique test file name. |
| const testing::TestInfo *const testInfo = |
| testing::UnitTest::GetInstance()->current_test_info(); |
| inputFileName = std::string(testInfo->name()) + "_test-file.f90"; |
| |
| // Create the input file stream. Note that this stream is populated |
| // separately in every test (i.e. the input is test specific). |
| inputFileOs = std::make_unique<llvm::raw_fd_ostream>( |
| inputFileName, ec, llvm::sys::fs::OF_None); |
| if (ec) |
| FAIL() << "Failed to create the input file"; |
| |
| // Get the path of the input file. |
| llvm::SmallString<256> cwd; |
| if (std::error_code ec = llvm::sys::fs::current_path(cwd)) |
| FAIL() << "Failed to obtain the current working directory"; |
| inputFilePath = cwd.c_str(); |
| inputFilePath += "/" + inputFileName; |
| |
| // Prepare the compiler (CompilerInvocation + CompilerInstance) |
| compInst.createDiagnostics(); |
| invoc = std::make_shared<CompilerInvocation>(); |
| |
| // Set-up default target triple and initialize LLVM Targets so that the |
| // target data layout can be passed to the frontend. |
| invoc->getTargetOpts().triple = |
| llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple()); |
| llvm::InitializeAllTargets(); |
| llvm::InitializeAllTargetMCs(); |
| |
| compInst.setInvocation(std::move(invoc)); |
| compInst.getFrontendOpts().inputs.push_back( |
| FrontendInputFile(inputFilePath, Language::Fortran)); |
| } |
| |
| void TearDown() override { |
| // Clear the input file. |
| llvm::sys::fs::remove(inputFileName); |
| |
| // Clear the output files. |
| // Note that these tests use an output buffer (as opposed to an output |
| // file), hence there are no physical output files to delete and |
| // `EraseFiles` is set to `false`. Also, some actions (e.g. |
| // `ParseSyntaxOnly`) don't generated output. In such cases there's no |
| // output to clear and `ClearOutputFile` returns immediately. |
| compInst.clearOutputFiles(/*EraseFiles=*/false); |
| } |
| }; |
| |
| TEST_F(FrontendActionTest, TestInputOutput) { |
| // Populate the input file with the pre-defined input and flush it. |
| *(inputFileOs) << "End Program arithmetic"; |
| inputFileOs.reset(); |
| |
| // Set-up the action kind. |
| compInst.getInvocation().getFrontendOpts().programAction = InputOutputTest; |
| |
| // Set-up the output stream. Using output buffer wrapped as an output |
| // stream, as opposed to an actual file (or a file descriptor). |
| llvm::SmallVector<char, 256> outputFileBuffer; |
| std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream( |
| new llvm::raw_svector_ostream(outputFileBuffer)); |
| compInst.setOutputStream(std::move(outputFileStream)); |
| |
| // Execute the action. |
| bool success = executeCompilerInvocation(&compInst); |
| |
| // Validate the expected output. |
| EXPECT_TRUE(success); |
| EXPECT_TRUE(!outputFileBuffer.empty()); |
| EXPECT_TRUE(llvm::StringRef(outputFileBuffer.data()) |
| .starts_with("End Program arithmetic")); |
| } |
| |
| TEST_F(FrontendActionTest, PrintPreprocessedInput) { |
| // Populate the input file with the pre-defined input and flush it. |
| *(inputFileOs) << "#ifdef NEW\n" |
| << " Program A \n" |
| << "#else\n" |
| << " Program B\n" |
| << "#endif"; |
| inputFileOs.reset(); |
| |
| // Set-up the action kind. |
| compInst.getInvocation().getFrontendOpts().programAction = |
| PrintPreprocessedInput; |
| compInst.getInvocation().getPreprocessorOpts().noReformat = true; |
| |
| // Set-up the output stream. We are using output buffer wrapped as an output |
| // stream, as opposed to an actual file (or a file descriptor). |
| llvm::SmallVector<char, 256> outputFileBuffer; |
| std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream( |
| new llvm::raw_svector_ostream(outputFileBuffer)); |
| compInst.setOutputStream(std::move(outputFileStream)); |
| |
| // Execute the action. |
| bool success = executeCompilerInvocation(&compInst); |
| |
| // Validate the expected output. |
| EXPECT_TRUE(success); |
| EXPECT_TRUE(!outputFileBuffer.empty()); |
| EXPECT_TRUE( |
| llvm::StringRef(outputFileBuffer.data()).starts_with("program b\n")); |
| } |
| |
| TEST_F(FrontendActionTest, ParseSyntaxOnly) { |
| // Populate the input file with the pre-defined input and flush it. |
| *(inputFileOs) << "IF (A > 0.0) IF (B < 0.0) A = LOG (A)\n" |
| << "END"; |
| inputFileOs.reset(); |
| |
| // Set-up the action kind. |
| compInst.getInvocation().getFrontendOpts().programAction = ParseSyntaxOnly; |
| |
| // Set-up the output stream for the semantic diagnostics. |
| llvm::SmallVector<char, 256> outputDiagBuffer; |
| std::unique_ptr<llvm::raw_pwrite_stream> outputStream( |
| new llvm::raw_svector_ostream(outputDiagBuffer)); |
| compInst.setSemaOutputStream(std::move(outputStream)); |
| |
| // Execute the action. |
| bool success = executeCompilerInvocation(&compInst); |
| |
| // Validate the expected output. |
| EXPECT_FALSE(success); |
| EXPECT_TRUE(!outputDiagBuffer.empty()); |
| EXPECT_TRUE( |
| llvm::StringRef(outputDiagBuffer.data()) |
| .contains( |
| ":1:14: error: IF statement is not allowed in IF statement\n")); |
| } |
| |
| TEST_F(FrontendActionTest, EmitLLVM) { |
| // Populate the input file with the pre-defined input and flush it. |
| *(inputFileOs) << "end program"; |
| inputFileOs.reset(); |
| |
| // Set-up the action kind. |
| compInst.getInvocation().getFrontendOpts().programAction = EmitLLVM; |
| |
| // Initialise LLVM backend |
| llvm::InitializeAllAsmPrinters(); |
| |
| // Set-up the output stream. We are using output buffer wrapped as an output |
| // stream, as opposed to an actual file (or a file descriptor). |
| llvm::SmallVector<char> outputFileBuffer; |
| std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream( |
| new llvm::raw_svector_ostream(outputFileBuffer)); |
| compInst.setOutputStream(std::move(outputFileStream)); |
| |
| // Execute the action. |
| bool success = executeCompilerInvocation(&compInst); |
| |
| // Validate the expected output. |
| EXPECT_TRUE(success); |
| EXPECT_TRUE(!outputFileBuffer.empty()); |
| |
| EXPECT_TRUE(llvm::StringRef(outputFileBuffer.begin(), outputFileBuffer.size()) |
| .contains("define void @_QQmain()")); |
| } |
| |
| TEST_F(FrontendActionTest, EmitAsm) { |
| // Populate the input file with the pre-defined input and flush it. |
| *(inputFileOs) << "end program"; |
| inputFileOs.reset(); |
| |
| // Set-up the action kind. |
| compInst.getInvocation().getFrontendOpts().programAction = EmitAssembly; |
| |
| // Initialise LLVM backend |
| llvm::InitializeAllAsmPrinters(); |
| |
| // Set-up the output stream. We are using output buffer wrapped as an output |
| // stream, as opposed to an actual file (or a file descriptor). |
| llvm::SmallVector<char, 256> outputFileBuffer; |
| std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream( |
| new llvm::raw_svector_ostream(outputFileBuffer)); |
| compInst.setOutputStream(std::move(outputFileStream)); |
| |
| // Execute the action. |
| bool success = executeCompilerInvocation(&compInst); |
| |
| // Validate the expected output. |
| EXPECT_TRUE(success); |
| EXPECT_TRUE(!outputFileBuffer.empty()); |
| |
| EXPECT_TRUE(llvm::StringRef(outputFileBuffer.begin(), outputFileBuffer.size()) |
| .contains("_QQmain")); |
| } |
| } // namespace |