[Flang][Driver] Add infrastructure for basic frontend actions and file I/O

[awarzynski]

Summary

This patch introduces the dependencies required to read and manage input files
provided by the command line option. It also adds the structure to create and
write to output files. The output is sent to either stdout or a file
(specified with the -o flag).

Separately, in order to be able to test the code for file I/O, it adds
infrastructure to create frontend actions. As a basic testable example, it adds
the InputOutputTest FrontendAction. The sole purpose of this action is to read
a file from the command line and print it either to stdout or the output file.
This action is run by using the -test-io flag also introduced in this patch, e.g.

flang-new -test-io or flang-new -fc1 -test-io

With this patch, flang-new -test-io input-file.f90 will read input-file.f90 and
print it in the output file.

The InputOutputTest action has been introduced to facilitate testing. It is
hidden from users, not being shown with --help. It is visible with
--help-hidden, and only available for FlangOption and FC1Options in Option.td.
Currently Clang doesn’t have an equivalent action.

-test-io is used to trigger the InputOutputTest action in the Flang frontend
driver. This patch also makes sure that “flang-new” forwards it to
“flang-new -fc1" by creating a preprocessor job. However, in Flang.cpp,
-test-io is passed to “flang-new -fc1” without -E so that the preprocessor is
_not_ run in the frontend driver. This is the desired behaviour: -test-io will
only read the input file and print it to the output stream.

[CarolineConcatto]

• remove changes from cmakefiles

[awarzynski]

@CarolineConcatto , thank you for this patch! It implements some really important functionality and IMO the overall structure is solid.

I've left quite a few comments, but mostly nits and suggestions for more detailed comments. There's a few, but it's a relatively big patch :)

One suggestion - IMO this patch first and foremost creates the scaffolding for writing frontend actions. The test-IO flag is only really there to facilitate testing. Perhaps it's worth updating the commit message to reflect that? I would definitely like to see a bit more emphasis on the fact that this patch introduces the necessary APIs for reading and writing files. For me that's the key functionality here.

Also, I tested this patch and currently -test-IO is listed together with other clang options (check clang --help-hidden). Please, could you fix that?

clang/include/clang/Driver/Options.td

3514

I think that test-io would be more consistent with other options in the file.

3515

I would help to make this a bit more specific. What about: Run the InputOuputTest action. Use for development and testing only?

clang/lib/Driver/ToolChains/Flang.cpp

39–40

It would be helpful to have a note that explains this change. Perhaps something like this:

// TODO: Note that eventually all actions will require a triple (e.g. `-triple aarch64-unknown-linux-gnu`). However, `-triple` is currently not supported by `flang-new -fc1`, so we only add it to actions that we don't support/execute just yet.

Probably above line 33. What do you think?

clang/lib/Driver/Types.cpp

329

This should probably be the last option here (as it's the latest to be added). Also, worth adding a comment about, e.g.:

-test-io is used by Flang to run InputOutputTest action

flang/include/flang/Frontend/CompilerInstance.h

26

[nit] Forrtran or Flang?

33

[nit] 'the outputFiles_' -> 'outputFiles_'

65

[nit] Delete

68

[nit] There is no source manager here.

It's probably worth decorating everything related to AllSources with:

/// }
/// @name File manager
/// {

flang/lib/Frontend/CompilerInstance.cpp

26

outputFiles_?

94–100

The stream is not flushed until it's destructor is called. This happens elsewhere. Here we just return the stream corresponding to the output file.

Since there's a distinction between seekable and non-seekable streams, I'd be tempted to split this as follows:

// Return the stream corresponding to the output file. For non-seekable streams, wrap it in llvm::buffer_ostream first.
  if (!binary || os->supportsSeeking())
    return std::move(os);
  
  assert(!nonSeekStream_ && "The non-seek stream has already been set!");
  auto b = std::make_unique<llvm::buffer_ostream>(*os);
  nonSeekStream_ = std::move(os);
  return std::move(b);

[awarzynski]

flang/include/flang/Frontend/CompilerInstance.h

40–42

[nit]

/// If the output doesn't support seeking (terminal, pipe), we switch
/// the stream to a buffer_ostream. These are the buffer and the original
/// stream.

vvv

/// Output stream that doesn't support seeking (e.g. terminal, pipe). This stream is normally wrapped
/// in buffer_ostream before being passed to users (e.g. via CreateOutputFile).

48

I think that:

This field holds the output stream provided by the user. Normally, users of CompilerInstance will call CreateOutputFile to obtain/create an output stream. If they want to provide their own output stream, this field will facilitate this. It is optional and will normally be just a nullptr.

would be a bit more informative :)

73

Missing /// }

76

[nit] No need to repeat the name of the method/member variable in comments. Same for the rest of the patch.

146–147

Remove Has a? Also, could you expand and clarify the differences between this method and the one below? Ta!

158

This argument is after binary

164

This argument is not documented.

171–177

[nit] I think that the comment is redundant - this is clear from the implementation and it is a fairly standard C++ idiom (e.g. accessors).

It's a good practice to use proper questions to name functions like this one, e.g. IsOutputStreamNull. Then, both possible return values answer this question. Sorry, I couldn't find a link that would document this.

Also, this would be simpler, yet semantically equivalent:

bool IsOutputStreamNull() {return (outputStream_ == nullptr);}

flang/include/flang/Frontend/FrontendAction.h

86

AFAIK, there is no source manager - only file manager.

flang/include/flang/Frontend/FrontendOptions.h

19–21

I recommend that this is replaced with:

InvalidAction = 0,

I think that this requires no comments.

111

Add message, e.g.

assert(IsBuffer() && "Requested buffer_, but it is empty!");

flang/lib/Frontend/FrontendActions.cpp

20

[nit] Get the name of the current file from FrontendInputFile

flang/test/Flang-Driver/driver-help-hidden.f90

8

[nit] Both --check-prefix=ERROR and --check-prefix=ERROR-HIDDEN check the help-hidden flang`. Perhaps --check-prefix=ERROR-FLANG-NEW and --check-prefix=ERROR-FLANG-NEW-FC1 would make the difference between the two cases more obvious?

28

This is the expected error for both flang-new (compiler driver) and flang-new -fc1 (the frontend driver).

flang/test/Flang-Driver/emit-obj.f90

2

Why is this line deleted? flang-new -emit-obj should still fail, right?

12

I'd be tempted just to delete this line - we have tests elsewhere to show that -o is indeed supported.

flang/test/Frontend/multiple-input-files.f90

2

I think that this test will be much more interesting and useful if empty-file.f90 is not empty :)

[CarolineConcatto]

Solve review comments

[CarolineConcatto]

@awarzynski thank you for the review.
It is a big patch to review at once.
I accepted almost all of your changes.

flang/test/Flang-Driver/emit-obj.f90

2

I remove this because the text does not apply any more
! ERROR-IMPLICIT: error: unknown argument: '-o'

[CarolineConcatto]

Rebase on top of master

[awarzynski]

@CarolineConcatto thank you again for working on this! The structure is good, but IMHO this patch could be polished a bit more. Overall:

• could you make sure that this patch does not change the output from clang -help?
• doxygen comments are consistent
• unittests are a bit better documentated (what and why is tested?)
• use llvm/Support/FileSystem.h instead of <filesystem>

More comments inline. Otherwise, I think that this is almost ready :)

clang/include/clang/Driver/Options.td

2784

What about FlangOption?

clang/lib/Driver/Driver.cpp

1576–1579 ↗

(On Diff #294356)

With this, the following is empty:

$ bin/clang --help | grep help

This is what I'd expect instead (i.e. the behavior shouldn't change):

$ bin/clang --help | grep help
  --help-hidden           Display help for hidden options
  -help                   Display available options

This needs a bit more polishing.

clang/test/Driver/immediate-options.c

5 ↗

(On Diff #294356)

HELP instead of HEKP

Could add a comment why this particular test is here?

flang/include/flang/Frontend/CompilerInstance.h

56

I can't see a matching /// } for this. DELETEME

83

From what I can see, this is not the case. Could you update?

flang/include/flang/Frontend/FrontendAction.h

24

DELETEME (missing matching /// {)

43

I think that this should be on line 38.

flang/include/flang/Frontend/FrontendOptions.h

16

[nit] Empty line

19

Temporary solution to what?

56–60

Could we defer adding this to later? This patch is already rather larger.

flang/lib/Frontend/CompilerInvocation.cpp

72

Please, could we defer this to later?

flang/lib/Frontend/FrontendOptions.cpp

18–23

Could you reduce it to Language::Fortran only? We can deal with various variants in a separate patch when it becomes relevant.

flang/test/Flang-Driver/driver-help.f90

14 ↗

(On Diff #294356)

Probably should be at the top (for consistency with driver-help-hidden.f90)

22 ↗

(On Diff #294356)

What about -o?

flang/test/Flang-Driver/emit-obj.f90

2

flang-new -emit-obj is still failing (which is expected) and we should have a test for it. Please revert this.

flang/unittests/Frontend/CompilerInstanceTest.cpp

21

Please use "llvm/Support/FileSystem.h" instead.

35

Please use FAIL() instead: https://github.com/google/googletest/blob/master/googletest/docs/advanced.md#explicit-success-and-failure

45

[nit] allSources is only used in one place - this variable is not needed

57

Forgot to test check the error code.

flang/unittests/Frontend/InputOutputTest.cpp

19

Please, use "llvm/Support/FileSystem.h" instead.

23

[nit] This is a test for InputOutputTestAction, perhaps:

TEST(FrontendAction, TestInputOutputStreamOwned)

?

llvm/lib/Option/OptTable.cpp

642 ↗

(On Diff #294356)

Revert

[CarolineConcatto]

address reviews comment

[CarolineConcatto]

@awarzynski patch updated.

[awarzynski]

LGTM, thanks for working on this!

As this is a fairly large change, could you wait for one more reviewer to approve? Thanks!

[awarzynski]

@reviewers A note regarding the changes in Clang.

This patch introduces a Flang option (-test-io), that should not be available/visible in Clang. AFAIK, there's no precedent of that, hence options::NoClangOption is introduced. This is discussed in more detail here: http://lists.llvm.org/pipermail/cfe-dev/2020-October/066953.html.

[SouraVX]

Thanks for the patch! Overall it's in pretty nice state and conformant to design highlighted.
Could you please clang-format this patch, There are lot of lint warning that causes lot of noise while reviewing.
Couple of NIT comments inline. I've tried marking all but, Could you please finish comments with period.

I think it would good if someone from clang community can also take a brief look.

clang/include/clang/Driver/Options.td

63

NoClangOption ? Is this a Typo, or am I missing the intent behind this ?

clang/lib/Driver/Driver.cpp

1579 ↗

(On Diff #296066)

NIT: May choose to avoid trivial braces.
https://llvm.org/docs/CodingStandards.html#don-t-use-braces-on-simple-single-statement-bodies-of-if-else-loop-statements

flang/include/flang/Frontend/CompilerInstance.h

131

NIT: Blank line ?

220

NIT: Please finish the comment with a period.

flang/lib/Frontend/CompilerInstance.cpp

66

NIT: Missing period at the end ?

67

Can this be simplified ? Maybe a switch case ?

flang/lib/Frontend/FrontendActions.cpp

26

NIT: Instance ? and period at end ?

[awarzynski]

Thank you for reviewing @SouraVX! I'm just about to submit an updated patch with the requested changes.

@CarolineConcatto has recently moved to a different project and so it will be mostly me updating this. @CarolineConcatto , thanks for all the effort!

clang/include/clang/Driver/Options.td

63

Yup, a typo, thanks!

flang/include/flang/Frontend/CompilerInstance.h

131

That's the convention for Doxygen, isn't it?

flang/lib/Frontend/CompilerInstance.cpp

67

Switch statement would be tricky, but I agree that this is unnecessarily complex.

[awarzynski]

Address PR comments, clang-format, rebase

[awarzynski]

I've added more reviewers for the Clang side of this patch. I choose people who most recently changed the functions/files that this patch modifies. Any input much appreciated! For more context regarding Clang changes: http://lists.llvm.org/pipermail/cfe-dev/2020-October/066953.html

[awarzynski]

Simplify the API for creating output files

The originally implemented API was overly complicated and not yet required.

[awarzynski]

Ping

[SouraVX]

Thanks for your patience. LGTM! at least the part I reviewed. Though I would vote for having another approval(From some senior folks in community)

[richard.barton.arm]

I'm happy to accept this revision based on @SouraVX 's code review and the fact that Andrzej has sent multiple RFCs covering the clang-side changes, including the Options flags (latest here http://lists.llvm.org/pipermail/cfe-dev/2020-October/067079.html). I think this code is good enough to commit.

Thanks for the code and reviews!

[awarzynski]

Thank you all for your input! Before merging I took the liberty to rename NoClangOption as FlangOnlyOption. The new name reflects better what the flag is introduced for. Also, based on responses to [1], it is unlikely that it will be used beyond flang-only options. If that changes we can always rename it.

[1] http://lists.llvm.org/pipermail/cfe-dev/2020-October/066953.html

clang/include/clang/Driver/Options.td

 // If an option affects linking, but has a primary group (so Link_Group cannot
 // be used), add this flag.
 def LinkOption : OptionFlag;
 
 // FlangOption - This is considered a "core" Flang option, available in
 // flang mode.
 def FlangOption : OptionFlag;
 
 // FC1Option - This option should be accepted by flang -fc1.
 def FC1Option : OptionFlag;
 
 // A short name to show in documentation. The name will be interpreted as rST.
 class DocName<string name> { string DocName = name; }
 
 // A brief description to show in documentation, interpreted as rST.
 class DocBrief<code descr> { code DocBrief = descr; }
 

 def nostartfiles : Flag<["-"], "nostartfiles">, Group<Link_Group>;
 def nostdinc : Flag<["-"], "nostdinc">, Flags<[CoreOption]>;
 def nostdlibinc : Flag<["-"], "nostdlibinc">;
 def nostdincxx : Flag<["-"], "nostdinc++">, Flags<[CC1Option]>,
   HelpText<"Disable standard #include directories for the C++ standard library">;
 def nostdlib : Flag<["-"], "nostdlib">, Group<Link_Group>;
 def nostdlibxx : Flag<["-"], "nostdlib++">;
 def object : Flag<["-"], "object">;
-def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption]>,
+def o : JoinedOrSeparate<["-"], "o">, Flags<[DriverOption, RenderAsInput, CC1Option, CC1AsOption, FC1Option]>,
   HelpText<"Write output to <file>">, MetaVarName<"<file>">;
 def pagezero__size : JoinedOrSeparate<["-"], "pagezero_size">;
 def pass_exit_codes : Flag<["-", "--"], "pass-exit-codes">, Flags<[Unsupported]>;
 def pedantic_errors : Flag<["-", "--"], "pedantic-errors">, Group<pedantic_Group>, Flags<[CC1Option]>;
 def pedantic : Flag<["-", "--"], "pedantic">, Group<pedantic_Group>, Flags<[CC1Option]>;
 def pg : Flag<["-"], "pg">, HelpText<"Enable mcount instrumentation">, Flags<[CC1Option]>;
 def pipe : Flag<["-", "--"], "pipe">,
   HelpText<"Use pipes between commands, when possible">;

 def fsycl : Flag<["-"], "fsycl">, Group<sycl_Group>, Flags<[CC1Option, CoreOption]>,
   HelpText<"Enable SYCL kernels compilation for device">;
 def fno_sycl : Flag<["-"], "fno-sycl">, Group<sycl_Group>, Flags<[CoreOption]>,
   HelpText<"Disable SYCL kernels compilation for device">;
 def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
   HelpText<"SYCL language standard to compile for.">, Values<"2017, 121, 1.2.1, sycl-1.2.1">;
 
 //===----------------------------------------------------------------------===//
+// FlangOption and FC1 Options
+//===----------------------------------------------------------------------===//
+def TEST_IO : Flag<["-"], "test-IO">, Flags<[HelpHidden, FlangOption, FC1Option]>,Group<Action_Group>,
+HelpText<"Only run the InputOutputTest action">;
+
+//===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 //===----------------------------------------------------------------------===//
 // Target Options
 //===----------------------------------------------------------------------===//

clang/lib/Driver/ToolChains/Flang.cpp

void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   const auto &TC = getToolChain();
   const llvm::Triple &Triple = TC.getEffectiveTriple();
   const std::string &TripleStr = Triple.getTriple();
 
   ArgStringList CmdArgs;
 
   CmdArgs.push_back("-fc1");
 
-  CmdArgs.push_back("-triple");
-  CmdArgs.push_back(Args.MakeArgString(TripleStr));
-
   if (isa<PreprocessJobAction>(JA)) {
+    if (C.getArgs().hasArg(options::OPT_TEST_IO))
+      CmdArgs.push_back("-test-IO");
+    else
       CmdArgs.push_back("-E");
   } else if (isa<CompileJobAction>(JA) || isa<BackendJobAction>(JA)) {
+    CmdArgs.push_back("-triple");
+    CmdArgs.push_back(Args.MakeArgString(TripleStr));
     if (JA.getType() == types::TY_Nothing) {
       CmdArgs.push_back("-fsyntax-only");
     } else if (JA.getType() == types::TY_AST) {
       CmdArgs.push_back("-emit-ast");
     } else if (JA.getType() == types::TY_LLVM_IR ||
                JA.getType() == types::TY_LTO_IR) {
       CmdArgs.push_back("-emit-llvm");
     } else if (JA.getType() == types::TY_LLVM_BC ||
                JA.getType() == types::TY_LTO_BC) {
       CmdArgs.push_back("-emit-llvm-bc");
     } else if (JA.getType() == types::TY_PP_Asm) {
       CmdArgs.push_back("-S");
     } else {
       assert(false && "Unexpected output type!");
     }
   } else if (isa<AssembleJobAction>(JA)) {
+    CmdArgs.push_back("-triple");
+    CmdArgs.push_back(Args.MakeArgString(TripleStr));
     CmdArgs.push_back("-emit-obj");
   } else {
     assert(false && "Unexpected action class for Flang tool.");
   }
 
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());

clang/lib/Driver/Types.cpp

 types::getCompilationPhases(const clang::driver::Driver &Driver,
                             llvm::opt::DerivedArgList &DAL, ID Id) {
   phases::ID LastPhase;
 
   // Filter to compiler mode. When the compiler is run as a preprocessor then
   // compilation is not an option.
   // -S runs the compiler in Assembly listing mode.
   if (Driver.CCCIsCPP() || DAL.getLastArg(options::OPT_E) ||
+      DAL.getLastArg(options::OPT_TEST_IO) ||
       DAL.getLastArg(options::OPT__SLASH_EP) ||
       DAL.getLastArg(options::OPT_M, options::OPT_MM) ||
       DAL.getLastArg(options::OPT__SLASH_P))
     LastPhase = phases::Preprocess;
 
   // --precompile only runs up to precompilation.
   // This is a clang extension and is not compatible with GCC.
   else if (DAL.getLastArg(options::OPT__precompile))

flang/CMakeLists.txt

 endif()
 
 # option() honors normal variables.
 if (POLICY CMP0077)
   cmake_policy(SET CMP0077 NEW)
 endif()
 
 option(LINK_WITH_FIR "Link driver with FIR and LLVM" ON)
-option(FLANG_BUILD_NEW_DRIVER "Build the flang compiler driver" OFF)
+option(FLANG_BUILD_NEW_DRIVER "Build the flang compiler driver"   OFF)
 
 # Flang requires C++17.
 set(CMAKE_CXX_STANDARD 17)
 set(CMAKE_CXX_STANDARD_REQUIRED TRUE)
 set(CMAKE_CXX_EXTENSIONS OFF)
 
 set(FLANG_SOURCE_DIR ${CMAKE_CURRENT_SOURCE_DIR})
 

flang/include/flang/Frontend/CompilerInstance.h

 //===-- CompilerInstance.h - Flang Compiler Instance ------------*- 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 LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H
 #define LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H
 
 #include "flang/Frontend/CompilerInvocation.h"
+#include "flang/Frontend/FrontendAction.h"
+#include "flang/Parser/provenance.h"
+#include "llvm/Support/raw_ostream.h"
 
 #include <cassert>
 #include <memory>
 
 namespace Fortran::frontend {
 
 class CompilerInstance {
 
   /// The options used in this compiler instance.
   std::shared_ptr<CompilerInvocation> invocation_;
 
+  /// The Fortran  file  manager.
+  std::shared_ptr<Fortran::parser::AllSources> allSources_;
+
   /// The diagnostics engine instance.
   llvm::IntrusiveRefCntPtr<clang::DiagnosticsEngine> diagnostics_;
 
+  /// Holds the name of the output file.
+  /// Helps to go through the list when working with the outputFiles_
+  struct OutputFile {
+    std::string filename_;
+    OutputFile(std::string inputFilename)
+        : filename_(std::move(inputFilename)) {}
+  };
+
+  /// If the output doesn't support seeking (terminal, pipe), we switch
+  /// the stream to a buffer_ostream. These are the buffer and the original
+  /// stream.
+  std::unique_ptr<llvm::raw_fd_ostream> nonSeekStream_;
+
+  /// The list of active output files.
+  std::list<OutputFile> outputFiles_;
+
+  /// Force an output buffer.
+  std::unique_ptr<llvm::raw_pwrite_stream> outputStream_;
+
 public:
   explicit CompilerInstance();
 
   ~CompilerInstance();
+
+  /// }
+  /// @name Compiler Invocation and Options
+  /// {
+
   CompilerInvocation &GetInvocation() {
     assert(invocation_ && "Compiler instance has no invocation!");
     return *invocation_;
   };
 
+  /// setInvocation - Replace the current invocation.
+  void SetInvocation(std::shared_ptr<CompilerInvocation> value);
+
+  /// Return the current source manager.
+  Fortran::parser::AllSources &GetAllSources() const { return *allSources_; }
+
+  bool HasAllSources() const { return allSources_ != nullptr; }
+
+  /// @name High-Level Operations
+  /// {
+
+  /// ExecuteAction - Execute the provided action against the compiler's
+  /// CompilerInvocation object.
+  /// Note that this routine may write output to 'stderr'.
+  /// \param act - The action to execute.
+  /// \return - True on success.
+  bool ExecuteAction(FrontendAction &act);
+
   /// }
   /// @name Forwarding Methods
   /// {
 
   clang::DiagnosticOptions &GetDiagnosticOpts() {
     return invocation_->GetDiagnosticOpts();
   }
   const clang::DiagnosticOptions &GetDiagnosticOpts() const {
     return invocation_->GetDiagnosticOpts();
public:
   }
 
   /// Get the current diagnostics engine.
   clang::DiagnosticsEngine &getDiagnostics() const {
     assert(diagnostics_ && "Compiler instance has no diagnostics!");
     return *diagnostics_;
   }
 
+  /// {
+  /// @name Output Files
+  /// {
+
+  /// AddOutputFile - Add an output file onto the list of tracked output files.
+  ///
+  /// \param outFile - The output file info.
+  void AddOutputFile(OutputFile &&outFile);
+
+  /// clearOutputFiles - Clear the output file list.
+  void ClearOutputFiles(bool eraseFiles);
+
+  /// Create the default output file (from the invocation's options) and add it
+  /// to the list of tracked output files.
+  ///
+  /// \return - Null on error.
+  std::unique_ptr<llvm::raw_pwrite_stream>
+  CreateDefaultOutputFile(bool binary = true, llvm::StringRef inFile = "",
+                          llvm::StringRef extension = "");
+
+  /// Has a function to create a new output file and add it to the list of
+  /// tracked output files.
+  ///
+  /// \return - Null on error.
+  std::unique_ptr<llvm::raw_pwrite_stream>
+  CreateOutputFile(llvm::StringRef outputPath, bool binary,
+                   llvm::StringRef inFile, llvm::StringRef extension);
+
+  /// Create a new output file.
+  ///
+  /// \param outputPath - If given, the path to the output file.
+  /// \param error [out] - On failure, the error.
+  /// \param extension - The extension to use for derived output names.
+  /// \param binary - The mode to open the file in.
+  /// \param resultPathName [out] - If given, the result path name will be
+  /// stored here on success.
+  std::unique_ptr<llvm::raw_pwrite_stream>
+  CreateOutputFile(llvm::StringRef outputPath, std::error_code &error,
+                   bool binary, llvm::StringRef inFile,
+                   llvm::StringRef extension, std::string *resultPathName);
+
+  void SetOutputStream(std::unique_ptr<llvm::raw_pwrite_stream> outStream) {
+    outputStream_ = std::move(outStream);
+  }
+
+  // OutputStream is private and its contenct cannot be checked outside
+  // CompilerInstance.
+  bool NullOutputStream() {
+    if (outputStream_ == nullptr)
+      return true;
+    return false;
+  }
+
+  // OutputStream is private and its contenct cannot be written outside
+  // CompilerInstance.
+  // Allow the frontend compiler to write in the output stream
+  void WriteOutputStream(const std::string &message) {
+    *outputStream_ << message;
+  }
+
   /// }
   /// @name Construction Utility Methods
   /// {
 
   /// Create a DiagnosticsEngine object with a the TextDiagnosticPrinter.
   ///
   /// If no diagnostic client is provided, this creates a
   /// DiagnosticConsumer that is owned by the returned diagnostic
public:
   static clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine> CreateDiagnostics(
       clang::DiagnosticOptions *opts,
       clang::DiagnosticConsumer *client = nullptr, bool shouldOwnClient = true);
   void CreateDiagnostics(
       clang::DiagnosticConsumer *client = nullptr, bool shouldOwnClient = true);
 };
 
 } // end namespace Fortran::frontend
 #endif // LLVM_FLANG_FRONTEND_COMPILERINSTANCE_H

flang/include/flang/Frontend/CompilerInvocation.h

 //===- CompilerInvocation.h - Compiler Invocation Helper Data ---*- 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 LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 #define LLVM_FLANG_FRONTEND_COMPILERINVOCATION_H
 
 #include "flang/Frontend/FrontendOptions.h"
 #include "clang/Basic/Diagnostic.h"
 #include "clang/Basic/DiagnosticOptions.h"
 
 namespace Fortran::frontend {
 class CompilerInvocationBase {
 public:
-  /// Options controlling the diagnostic engine.$
+  /// Options controlling the diagnostic engine.
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagnosticOpts_;
 
   CompilerInvocationBase();
   CompilerInvocationBase(const CompilerInvocationBase &x);
   ~CompilerInvocationBase();
 
   clang::DiagnosticOptions &GetDiagnosticOpts() {
     return *diagnosticOpts_.get();

flang/include/flang/Frontend/FrontendAction.h

+//===- FrontendAction.h -----------------------------------------*- 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 LLVM_FLANG_FRONTEND_FRONTENDACTION_H
+#define LLVM_FLANG_FRONTEND_FRONTENDACTION_H
+
+#include "flang/Frontend/FrontendOptions.h"
+#include "llvm/Support/Error.h"
+
+namespace Fortran::frontend {
+class CompilerInstance;
+
+class FrontendAction {
+  FrontendInputFile currentInput_;
+  CompilerInstance *instance_;
+
+protected:
+  /// @}
+  /// @name Implementation Action Interface
+  /// @{
+
+  /// Callback to run the program action, using the initialized
+  /// compiler instance.
+  ///
+  virtual void ExecuteAction() = 0;
+
+  /// Callback at the end of processing a single input, to determine
+  /// if the output files should be erased or not.
+  ///
+  /// By default it returns true if a compiler error occurred.
+  virtual bool ShouldEraseOutputFiles();
+
+public:
+  FrontendAction() : instance_(nullptr) {}
+  virtual ~FrontendAction() = default;
+
+  /// @}
+  /// @name Compiler Instance Access
+  /// @{
+
+  CompilerInstance &GetCompilerInstance() const {
+    assert(instance_ && "Compiler instance not registered!");
+    return *instance_;
+  }
+  void SetCompilerInstance(CompilerInstance *value) { instance_ = value; }
+
+  /// @}
+  /// @name Current File Information
+  /// @{
+
+  const FrontendInputFile &GetCurrentInput() const { return currentInput_; }
+
+  llvm::StringRef GetCurrentFile() const {
+    assert(!currentInput_.IsEmpty() && "No current file!");
+    return currentInput_.GetFile();
+  }
+
+  llvm::StringRef GetCurrentFileOrBufferName() const {
+    assert(!currentInput_.IsEmpty() && "No current file!");
+    return currentInput_.IsFile()
+               ? currentInput_.GetFile()
+               : currentInput_.GetBuffer()->getBufferIdentifier();
+  }
+  void SetCurrentInput(const FrontendInputFile &currentInput);
+
+  /// @}
+  /// @name Public Action Interface
+  /// @}
+
+  /// Prepare the action for processing the input file \p input.
+  ///
+  /// This is run after the options and frontend have been initialized,
+  /// but prior to executing any per-file processing.
+  /// \param ci - The compiler instance this action is being run from. The
+  /// action may store and use this object.
+  /// \param input - The input filename and kind.
+  /// \return True on success; on failure the compilation of this file should
+  bool BeginSourceFile(CompilerInstance &ci, const FrontendInputFile &input);
+
+  /// Set the source manager's main input file, and run the action.
+  llvm::Error Execute();
+
+  /// Perform any per-file post processing, deallocate per-file
+  /// objects, and run statistics and output file cleanup code.
+  void EndSourceFile();
+};
+
+} // namespace Fortran::frontend
+
+#endif // LLVM_FLANG_FRONTEND_FRONTENDACTION_H
 No newline at end of file

flang/include/flang/Frontend/FrontendActions.h

+//===- FrontendActions.h -----------------------------------------*- 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 LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
+#define LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
+
+#include "flang/Frontend/FrontendAction.h"
+
+namespace Fortran::frontend {
+
+class InputOutputTestAction : public FrontendAction {
+  void ExecuteAction() override;
+};
+
+} // namespace Fortran::frontend
+
+#endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H
 No newline at end of file

flang/include/flang/Frontend/FrontendOptions.h

 //===- FrontendOptions.h ----------------------------------------*- 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 LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H
 #define LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H
 
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/MemoryBuffer.h"
+
 #include <cstdint>
 #include <string>
 namespace Fortran::frontend {
 
+enum ActionKind {
+  // This is temporary solution
+  // Avoids Action = PrintPreprocessedInput as option 0
+  DummyAction = 0,
+
+  /// -IO mode
+  InputOutputTest,
+
+  /// TODO: ADD flags as the Actions are implemented
+  // RunPreprocessor, ParserSyntaxOnly, EmitLLVM, EmitLLVMOnly,
+  // EmitCodeGenOnly, EmitAssembly, (...)
+};
+
+inline const char *GetActionKindName(const ActionKind ak) {
+  switch (ak) {
+  case InputOutputTest:
+    return "InputOutputTest";
+  default:
+    return "<unknown ActionKind>";
+    // TODO:
+    // case RunPreprocessor:
+    // case ParserSyntaxOnly:
+    // case EmitLLVM:
+    // case EmitLLVMOnly:
+    // case EmitCodeGenOnly:
+    // (...)
+  }
+}
+
 enum class Language : uint8_t {
   Unknown,
 
   /// LLVM IR: we accept this so that we can run the optimizer on it,
   /// and compile it to assembly or object code.
   LLVM_IR,
 
   ///@{ Languages that the frontend can parse and compile.
   Fortran,
-  ///@}
+  Fortran77,
+  Fortran90,
+  Fortran95,
+  FortranF18
 };
 
 /// The kind of a file that we've been handed as an input.
 class InputKind {
 private:
   Language lang_;
 
 public:
   /// The input file format.
   enum Format { Source, ModuleMap, Precompiled };
 
   constexpr InputKind(Language l = Language::Unknown) : lang_(l) {}
 
   Language GetLanguage() const { return static_cast<Language>(lang_); }
 
   /// Is the input kind fully-unknown?
   bool IsUnknown() const { return lang_ == Language::Unknown; }
 };
 
+/// An input file for the front end.
+class FrontendInputFile {
+  /// The file name, or "-" to read from standard input.
+  std::string file_;
+
+  /// The input, if it comes from a buffer rather than a file. This object
+  /// does not own the buffer, and the caller is responsible for ensuring
+  /// that it outlives any users.
+  const llvm::MemoryBuffer *buffer_ = nullptr;
+
+  /// The kind of input, atm it contains language
+  InputKind kind_;
+
+public:
+  FrontendInputFile() = default;
+  FrontendInputFile(llvm::StringRef file, InputKind kind)
+      : file_(file.str()), kind_(kind) {}
+  FrontendInputFile(const llvm::MemoryBuffer *buffer, InputKind kind)
+      : buffer_(buffer), kind_(kind) {}
+
+  InputKind GetKind() const { return kind_; }
+
+  bool IsEmpty() const { return file_.empty() && buffer_ == nullptr; }
+  bool IsFile() const { return !IsBuffer(); }
+  bool IsBuffer() const { return buffer_ != nullptr; }
+
+  llvm::StringRef GetFile() const {
+    assert(IsFile());
+    return file_;
+  }
+
+  const llvm::MemoryBuffer *GetBuffer() const {
+    assert(IsBuffer());
+    return buffer_;
+  }
+};
+
 /// FrontendOptions - Options for controlling the behavior of the frontend.
 class FrontendOptions {
 public:
   /// Show the -help text.
   unsigned showHelp_ : 1;
 
   /// Show the -version text.
   unsigned showVersion_ : 1;
 
+  /// The input files and their types.
+  std::vector<FrontendInputFile> inputs_;
+
+  /// The output file, if any.
+  std::string outputFile_;
+
+  /// The frontend action to perform.
+  frontend::ActionKind programAction_;
+
 public:
   FrontendOptions() : showHelp_(false), showVersion_(false) {}
+
+  // Return the appropriate input kind for a file extension. For example,
+  /// "f90" would return Language::Fortran90.
+  ///
+  /// \return The input kind for the extension, or Language::Unknown if the
+  /// extension is not recognized.
+  static InputKind GetInputKindForExtension(llvm::StringRef extension);
 };
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

flang/include/flang/FrontendTool/Utils.h

 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_FLANG_FRONTENDTOOL_UTILS_H
 #define LLVM_FLANG_FRONTENDTOOL_UTILS_H
 
 namespace Fortran::frontend {
 
 class CompilerInstance;
+class FrontendAction;
+
+/// Construct the FrontendAction of a compiler invocation based on the
+/// options specified for the compiler invocation.
+///
+/// \return - The created FrontendAction object
+std::unique_ptr<FrontendAction> CreateFrontendAction(CompilerInstance &ci);
 
 /// ExecuteCompilerInvocation - Execute the given actions described by the
 /// compiler invocation object in the given compiler instance.
 ///
 /// \return - True on success.
 bool ExecuteCompilerInvocation(CompilerInstance *flang);
 
 } // end namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTENDTOOL_UTILS_H

flang/lib/Frontend/CMakeLists.txt

 add_flang_library(flangFrontend
   CompilerInstance.cpp
   CompilerInvocation.cpp
+  FrontendAction.cpp
+  FrontendActions.cpp
   FrontendOptions.cpp
 
+  # ClangFrontend was added to help Diagnostic error
+  # Further work may be required
   LINK_LIBS
+  FortranParser
   clangBasic
   clangDriver
-  # TODO: Added to re-use clang's TextDiagnosticBuffer & TextDiagnosticPrinter.
-  # Add a custom implementation for Flang and remove this dependency.
   clangFrontend
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/Frontend/CompilerInstance.cpp

 //===--- CompilerInstance.cpp ---------------------------------------------===//
 //
 // 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/Parser/provenance.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "llvm/Support/Errc.h"
+#include "llvm/Support/Error.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Path.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace Fortran::frontend;
 
-CompilerInstance::CompilerInstance() : invocation_(new CompilerInvocation()) {}
+CompilerInstance::CompilerInstance()
+    : invocation_(new CompilerInvocation()),
+      allSources_(new Fortran::parser::AllSources()) {}
 
-CompilerInstance::~CompilerInstance() = default;
+CompilerInstance::~CompilerInstance() {
+  assert(OutputFiles.empty() && "Still output files in flight?");
+}
+
+void CompilerInstance::SetInvocation(
+    std::shared_ptr<CompilerInvocation> value) {
+  invocation_ = std::move(value);
+}
+
+void CompilerInstance::AddOutputFile(OutputFile &&outFile) {
+  outputFiles_.push_back(std::move(outFile));
+}
+
+std::unique_ptr<llvm::raw_pwrite_stream>
+CompilerInstance::CreateDefaultOutputFile(bool binary, llvm::StringRef inFile,
+                                          llvm::StringRef extension) {
+  return CreateOutputFile(GetFrontendOpts().outputFile_, binary, inFile,
+                          extension);
+}
+
+std::unique_ptr<llvm::raw_pwrite_stream>
+CompilerInstance::CreateOutputFile(llvm::StringRef outputPath, bool binary,
+                                   llvm::StringRef inFile,
+                                   llvm::StringRef extension) {
+  std::string outputPathName;
+  std::error_code ec;
+
+  std::unique_ptr<llvm::raw_pwrite_stream> os = CreateOutputFile(
+      outputPath, ec, binary, inFile, extension, &outputPathName);
+
+  AddOutputFile(OutputFile(outputPathName));
+  return os;
+}
+
+std::unique_ptr<llvm::raw_pwrite_stream> CompilerInstance::CreateOutputFile(
+    llvm::StringRef outputPath, std::error_code &error, bool binary,
+    llvm::StringRef inFile, llvm::StringRef extension,
+    std::string *resultPathName) {
+
+  std::string outFile;
+
+  // Create the name of the output file
+  if (!outputPath.empty()) {
+    outFile = std::string(outputPath);
+  } else if (inFile == "-") {
+    outFile = "-";
+  } else if (!extension.empty()) {
+    llvm::SmallString<128> path(inFile);
+    llvm::sys::path::replace_extension(path, extension);
+    outFile = std::string(path.str());
+  } else {
+    outFile = "-";
+  }
+
+  if (resultPathName)
+    *resultPathName = outFile;
+
+  // Creates the file descriptor for the output file
+  std::unique_ptr<llvm::raw_fd_ostream> os;
+  std::string osFile;
+  if (!os) {
+    osFile = outFile;
+    os.reset(new llvm::raw_fd_ostream(
+        osFile, error,
+        (binary ? llvm::sys::fs::OF_None : llvm::sys::fs::OF_Text)));
+    if (error)
+      return nullptr;
+  }
+
+  // Flushes the stream
+  if (!binary || os->supportsSeeking())
+    return std::move(os);
+  auto b = std::make_unique<llvm::buffer_ostream>(*os);
+  assert(!nonSeekStream_);
+  nonSeekStream_ = std::move(os);
+
+  return std::move(b);
+}
+
+void CompilerInstance::ClearOutputFiles(bool eraseFiles) {
+  for (OutputFile &of : outputFiles_)
+    if (!of.filename_.empty() && eraseFiles)
+      llvm::sys::fs::remove(of.filename_);
+
+  outputFiles_.clear();
+  nonSeekStream_.reset();
+}
+
+bool CompilerInstance::ExecuteAction(FrontendAction &act) {
+
+  // Connect Input to a CompileInstance
+  for (const FrontendInputFile &fif : GetFrontendOpts().inputs_) {
+    if (act.BeginSourceFile(*this, fif)) {
+      if (llvm::Error err = act.Execute()) {
+        consumeError(std::move(err));
+      }
+      act.EndSourceFile();
+    }
+  }
+  return true;
+}
 
 void CompilerInstance::CreateDiagnostics(
     clang::DiagnosticConsumer *client, bool shouldOwnClient) {
   diagnostics_ =
       CreateDiagnostics(&GetDiagnosticOpts(), client, shouldOwnClient);
 }
 
 clang::IntrusiveRefCntPtr<clang::DiagnosticsEngine>

flang/lib/Frontend/CompilerInvocation.cpp

 //===- CompilerInvocation.cpp ---------------------------------------------===//
 //
 // 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/CompilerInvocation.h"
 #include "clang/Basic/AllDiagnostics.h"
 #include "clang/Basic/DiagnosticDriver.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "clang/Driver/Options.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/ADT/StringSwitch.h"
 #include "llvm/Option/Arg.h"
static InputKind ParseFrontendArgs(FrontendOptions &opts,
     llvm::opt::ArgList &args, clang::DiagnosticsEngine &diags) {
   // Identify the action (i.e. opts.ProgramAction)
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_Action_Group)) {
     switch (a->getOption().getID()) {
     default: {
       llvm_unreachable("Invalid option in group!");
     }
+    case clang::driver::options::OPT_TEST_IO:
+      opts.programAction_ = InputOutputTest;
+      break;
       // TODO:
       // case clang::driver::options::OPT_E:
       // case clang::driver::options::OPT_emit_obj:
       // case calng::driver::options::OPT_emit_llvm:
       // case clang::driver::options::OPT_emit_llvm_only:
       // case clang::driver::options::OPT_emit_codegen_only:
       // case clang::driver::options::OPT_emit_module:
       // (...)
     }
   }
 
+  opts.outputFile_ = args.getLastArgValue(clang::driver::options::OPT_o);
   opts.showHelp_ = args.hasArg(clang::driver::options::OPT_help);
   opts.showVersion_ = args.hasArg(clang::driver::options::OPT_version);
 
   // Get the input kind (from the value passed via `-x`)
   InputKind dashX(Language::Unknown);
   if (const llvm::opt::Arg *a =
           args.getLastArg(clang::driver::options::OPT_x)) {
     llvm::StringRef XValue = a->getValue();
     // Principal languages.
     dashX = llvm::StringSwitch<InputKind>(XValue)
-                .Case("f90", Language::Fortran)
+                .Case("f90", Language::Fortran90)
                 .Default(Language::Unknown);
 
     // Some special cases cannot be combined with suffixes.
     if (dashX.IsUnknown())
       dashX = llvm::StringSwitch<InputKind>(XValue)
                   .Case("ir", Language::LLVM_IR)
                   .Default(Language::Unknown);
 
     if (dashX.IsUnknown())
       diags.Report(clang::diag::err_drv_invalid_value)
           << a->getAsString(args) << a->getValue();
   }
 
+  // Save input file to FrontendInputFile with kind and name
+  // '-' is the default input if none is given.
+  std::vector<std::string> inputs =
+      args.getAllArgValues(clang::driver::options::OPT_INPUT);
+  opts.inputs_.clear();
+  if (inputs.empty())
+    inputs.push_back("-");
+  for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
+    InputKind ik = dashX;
+    if (ik.IsUnknown()) {
+      ik = FrontendOptions::GetInputKindForExtension(
+          llvm::StringRef(inputs[i]).rsplit('.').second);
+      if (ik.IsUnknown())
+        ik = Language::Unknown;
+      if (i == 0)
+        dashX = ik;
+    }
+
+    opts.inputs_.emplace_back(std::move(inputs[i]), ik);
+  }
   return dashX;
 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;

flang/lib/Frontend/FrontendAction.cpp

+//===--- FrontendAction.cpp -----------------------------------------------===//
+//
+// 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/FrontendAction.h"
+#include "flang/Frontend/CompilerInstance.h"
+#include "flang/Frontend/FrontendActions.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/Errc.h"
+
+using namespace Fortran::frontend;
+
+void FrontendAction::SetCurrentInput(const FrontendInputFile &currentInput) {
+  this->currentInput_ = currentInput;
+}
+
+// Call this method if BeginSourceFile fails.
+// Deallocate compiler instance, input and output descriptors
+static void BeginSourceFileCleanUp(FrontendAction &fa, CompilerInstance &ci) {
+  ci.ClearOutputFiles(/*EraseFiles=*/true);
+  fa.SetCurrentInput(FrontendInputFile());
+  fa.SetCompilerInstance(nullptr);
+}
+
+bool FrontendAction::BeginSourceFile(CompilerInstance &ci,
+                                     const FrontendInputFile &realInput) {
+
+  FrontendInputFile input(realInput);
+  assert(!instance_ && "Already processing a source file!");
+  assert(!realInput.IsEmpty() && "Unexpected empty filename!");
+  SetCurrentInput(realInput);
+  SetCompilerInstance(&ci);
+  if (!ci.HasAllSources()) {
+    BeginSourceFileCleanUp(*this, ci);
+    return false;
+  }
+  return true;
+}
+
+bool FrontendAction::ShouldEraseOutputFiles() {
+  return GetCompilerInstance().getDiagnostics().hasErrorOccurred();
+}
+
+llvm::Error FrontendAction::Execute() {
+  ExecuteAction();
+  return llvm::Error::success();
+}
+
+void FrontendAction::EndSourceFile() {
+  CompilerInstance &ci = GetCompilerInstance();
+
+  // Cleanup the output streams, and erase the output files if instructed by the
+  // FrontendAction.
+  ci.ClearOutputFiles(/*EraseFiles=*/ShouldEraseOutputFiles());
+
+  SetCompilerInstance(nullptr);
+  SetCurrentInput(FrontendInputFile());
+}
 No newline at end of file

flang/lib/Frontend/FrontendActions.cpp

+//===--- FrontendActions.cpp ----------------------------------------------===//
+//
+// 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/FrontendActions.h"
+#include "flang/Common/Fortran-features.h"
+#include "flang/Common/default-kinds.h"
+#include "flang/Frontend/CompilerInstance.h"
+#include "flang/Parser/source.h"
+#include "clang/Serialization/PCHContainerOperations.h"
+
+using namespace Fortran::frontend;
+
+void InputOutputTestAction::ExecuteAction() {
+
+  // Get the name of the file from FrontendInputFile current
+  std::string path{GetCurrentFileOrBufferName()};
+  std::string buf;
+  llvm::raw_string_ostream error_stream{buf};
+  bool binaryMode = true;
+
+  // Set/store input file info into compiler instace
+  CompilerInstance &ci = GetCompilerInstance();
+  Fortran::parser::AllSources &allSources{ci.GetAllSources()};
+  const Fortran::parser::SourceFile *sf;
+  sf = allSources.Open(path, error_stream);
+  llvm::ArrayRef<char> fileContent = sf->content();
+
+  // Output file descriptor to receive the content of input file
+  std::unique_ptr<llvm::raw_ostream> os;
+
+  // Do not write on the output file if using outputStream_
+  if (ci.NullOutputStream()) {
+    os = ci.CreateDefaultOutputFile(binaryMode, GetCurrentFileOrBufferName(),
+                                    "txt");
+    if (!os)
+      return;
+    (*os) << fileContent.data();
+  } else {
+    ci.WriteOutputStream(fileContent.data());
+  }
+}

flang/lib/Frontend/FrontendOptions.cpp

 //===- FrontendOptions.cpp ------------------------------------------------===//
 //
 // 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/FrontendOptions.h"
+#include "llvm/ADT/StringSwitch.h"
+
+using namespace Fortran::frontend;
+
+InputKind FrontendOptions::GetInputKindForExtension(llvm::StringRef extension) {
+  return llvm::StringSwitch<InputKind>(extension)
+      // Spreading in cases to cover more extensions as API allows
+      // at most 9 items per case.
+      .Cases("ff", "fpp", "FPP", "cuf", "CUF", "fir", "FOR", "for",
+             Language::Fortran)
+      .Cases("f", "F", "f77", Language::Fortran77)
+      .Cases("f90", "F90", ".ff90", Language::Fortran90)
+      .Cases("f95", "F95", "ff95", Language::Fortran95)
+      .Cases("f18", "F18", Language::FortranF18)
+      .Default(Language::Unknown);
+}
 No newline at end of file

flang/lib/FrontendTool/CMakeLists.txt

 add_flang_library(flangFrontendTool
   ExecuteCompilerInvocation.cpp
 
   LINK_LIBS
+  flangFrontend
   clangBasic
   clangDriver
 
   LINK_COMPONENTS
   Option
   Support
 )

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

 //===--- ExecuteCompilerInvocation.cpp ------------------------------------===//
 //
 // 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 holds ExecuteCompilerInvocation(). It is split into its own file to
 // minimize the impact of pulling in essentially everything else in Flang.
 //
 //===----------------------------------------------------------------------===//
 
 #include "flang/Frontend/CompilerInstance.h"
+#include "flang/Frontend/FrontendActions.h"
 #include "clang/Driver/Options.h"
 #include "llvm/Option/OptTable.h"
+#include "llvm/Option/Option.h"
+#include "llvm/Support/BuryPointer.h"
 #include "llvm/Support/CommandLine.h"
 
 namespace Fortran::frontend {
+
+static std::unique_ptr<FrontendAction>
+CreateFrontendBaseAction(CompilerInstance &ci) {
+
+  ActionKind ak = ci.GetFrontendOpts().programAction_;
+  switch (ak) {
+  case InputOutputTest:
+    return std::make_unique<InputOutputTestAction>();
+    break;
+  default:
+    break;
+    // TODO:
+    // case RunPreprocessor:
+    // case ParserSyntaxOnly:
+    // case EmitLLVM:
+    // case EmitLLVMOnly:
+    // case EmitCodeGenOnly:
+    // (...)
+  }
+  return 0;
+}
+
+std::unique_ptr<FrontendAction> CreateFrontendAction(CompilerInstance &ci) {
+  // Create the underlying action.
+  std::unique_ptr<FrontendAction> act = CreateFrontendBaseAction(ci);
+  if (!act)
+    return nullptr;
+
+  return act;
+}
 bool ExecuteCompilerInvocation(CompilerInstance *flang) {
   // Honor -help.
   if (flang->GetFrontendOpts().showHelp_) {
-    clang::driver::getDriverOptTable().PrintHelp(llvm::outs(),
-        "flang-new -fc1 [options] file...", "LLVM 'Flang' Compiler",
+    clang::driver::getDriverOptTable().PrintHelp(
+        llvm::outs(), "flang-new -fc1 [options] file...",
+        "LLVM 'Flang' Compiler",
         /*Include=*/clang::driver::options::FlangOption,
-        /*Exclude=*/0, /*ShowAllAliases=*/false);
+        /*Exclude=*/llvm::opt::DriverFlag::HelpHidden,
+        /*ShowAllAliases=*/false);
     return true;
   }
 
   // Honor -version.
   if (flang->GetFrontendOpts().showVersion_) {
     llvm::cl::PrintVersionMessage();
     return true;
   }
 
-  return true;
+  // Create and execute the frontend action.
+  std::unique_ptr<FrontendAction> act(CreateFrontendAction(*flang));
+  if (!act)
+    return false;
+
+  bool success = flang->ExecuteAction(*act);
+  return success;
 }
 
 } // namespace Fortran::frontend

flang/test/Flang-Driver/driver-help-hidden.f90

+! REQUIRES: new-flang-driver
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! RUN: %flang-new --help-hidden 2>&1 | FileCheck %s
+! RUN: not %flang-new  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR
+
+!----------------------------------------
+! FLANG FRONTEND DRIVER (flang-new -fc1)
+!----------------------------------------
+! RUN: not %flang-new -fc1 --help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-HIDDEN
+! RUN: not %flang-new -fc1  -help-hidden 2>&1 | FileCheck %s --check-prefix=ERROR-HIDDEN
+
+
+!----------------------------------------------------
+! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)
+!----------------------------------------------------
+! CHECK:USAGE: flang-new
+! CHECK-EMPTY:
+! CHECK-NEXT:OPTIONS:
+! CHECK-NEXT: -help     Display available options
+! CHECK-NEXT: -test-IO       Only run the InputOutputTest action
+! CHECK-NEXT: --version Print version information
+
+!-------------------------------------------------------------
+! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
+!-------------------------------------------------------------
+! Frontend driver -help-hidden is not supported (aking to clang)
+! ERROR-HIDDEN: error: unknown argument: '{{.*}}'
+! ERROR: error: unknown argument '-help-hidden'; did you mean '--help-hidden'?
+

flang/test/Flang-Driver/emit-obj.f90

 ! RUN: not %flang-new  %s 2>&1 | FileCheck %s --check-prefix=ERROR-IMPLICIT
-! RUN: not %flang-new  -emit-obj %s 2>&1 | FileCheck %s --check-prefix=ERROR-EXPLICIT
 ! RUN: not %flang-new  -fc1 -emit-obj %s 2>&1 | FileCheck %s --check-prefix=ERROR-FC1
 
 ! REQUIRES: new-flang-driver
 
 ! By default (e.g. when no options like `-E` are passed) flang-new
 ! creates a job that corresponds to `-emit-obj`. This option/action is
 ! not yet supported. Verify that this is correctly reported as error.
 
 ! ERROR-IMPLICIT: error: unknown argument: '-triple'
 ! ERROR-IMPLICIT: error: unknown argument: '-emit-obj'
-! ERROR-IMPLICIT: error: unknown argument: '-o'
-
-! ERROR-EXPLICIT: error: unknown argument: '-o'
+! ERROR-IMPLICIT-NOT: error: unknown argument: '-o'
 
 ! ERROR-FC1: error: unknown argument: '-emit-obj'

flang/test/Frontend/input-output-file.f90

+! RUN: rm -rf %S/input-output-file.txt
+
+! REQUIRES: new-flang-driver
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! TEST 1: Print to stdout (implicit)
+! RUN: %flang-new -test-IO %s  2>&1 | FileCheck %s
+! TEST 2: Print to stdout (explicit)
+! RUN: %flang-new -test-IO -o - %s  2>&1 | FileCheck %s
+! TEST 3: Print to a file
+! RUN: %flang-new -test-IO -o %t %s 2>&1 && FileCheck %s --input-file=%t
+
+!----------------------------------------
+! FLANG FRONTEND DRIVER (flang-new -fc1)
+!----------------------------------------
+! TEST 4: Write to a file (implicit)
+! RUN: %flang-new -fc1 -test-IO  %s 2>&1 && FileCheck %s --input-file=%S/input-output-file.txt
+! TEST 5: Write to a file (explicit)
+! RUN: %flang-new -fc1 -test-IO  -o %t %s 2>&1 && FileCheck %s --input-file=%t
+
+
+!-----------------------
+! EXPECTED OUTPUT
+!-----------------------
+! CHECK-LABEL: Program arithmetic
+! CHECK-NEXT:    Integer :: i, j
+! CHECK-NEXT:    i = 2; j = 3; i= i * j;
+! CHECK-NEXT:  End Program arithmetic
+
+Program arithmetic
+  Integer :: i, j
+  i = 2; j = 3; i= i * j;
+End Program arithmetic
 No newline at end of file

flang/test/Frontend/multiple-input-files.f90

+! RUN: rm -rf %S/multiple-input-files.txt  %S/Inputs/empty-file.txt
+
+! REQUIRES: new-flang-driver
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! TEST 1: Both input files are processed (output is printed to stdout)
+! RUN: %flang-new -test-IO %s %S/Inputs/empty-file.f90 | FileCheck %s  -check-prefix=flang-new
+
+! TEST 2: None of the files is processed (not possible to specify the output file when multiple input files are present)
+! RUN: not %flang-new -test-IO -o - %S/Inputs/empty-file.f90 %s  2>&1 | FileCheck %s -check-prefix=ERROR
+! RUN: not %flang-new -test-IO -o %t %S/Inputs/empty-file.f90 %s 2>&1 | FileCheck %s -check-prefix=ERROR
+
+!----------------------------------------
+! FLANG FRONTEND DRIVER (flang-new -fc1)
+!----------------------------------------
+! TEST 3: Both input files are processed
+! RUN: %flang-new -fc1 -test-IO  %S/Inputs/empty-file.f90 %s 2>&1 \
+! RUN:  && FileCheck %s --input-file=%S/multiple-input-files.txt -check-prefix=flang-new-FC1-OUTPUT1 
+
+! TEST 4: Only the last input file is processed
+! RUN: %flang-new -fc1 -test-IO  %S/Inputs/empty-file.f90 %s -o %t 2>&1 \
+! RUN:  && FileCheck %s --input-file=%t -check-prefix=flang-new-FC1-OUTPUT1
+
+!-----------------------
+! EXPECTED OUTPUT
+!-----------------------
+! TEST 1: By default, `flang-new` prints the output from all input files to
+! stdout
+! flang-new-LABEL: Program arithmetic
+! flang-new-NEXT:    Integer :: i, j
+! flang-new-NEXT:    i = 2; j = 3; i= i * j;
+! flang-new-NEXT:  End Program arithmetic
+
+
+! TEST 2: `-o` does not work for `flang-new` when multiple input files are present
+! ERROR:error: cannot specify -o when generating multiple output files
+
+
+! TEST 3 & TEST 4: Unless the output file is specified, `flang-new -fc1` generates one output file for every input file. If an
+! output file is specified (with `-o`), then only the last input file is processed.
+! flang-new-FC1-OUTPUT1-LABEL: Program arithmetic
+! flang-new-FC1-OUTPUT1-NEXT:    Integer :: i, j
+! flang-new-FC1-OUTPUT1-NEXT:    i = 2; j = 3; i= i * j;
+! flang-new-FC1-OUTPUT1-NEXT:  End Program arithmetic
+
+
+
+Program arithmetic
+  Integer :: i, j
+  i = 2; j = 3; i= i * j;
+End Program arithmetic
 No newline at end of file

flang/test/lit.cfg.py

 # directories.
 config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 
 # If the new Flang driver is enabled, add the corresponding feature to
 # config. Otherwise, exclude the corresponding test directory.
 if config.include_flang_new_driver_test:
   config.available_features.add('new-flang-driver')
 else:
-  config.excludes.append('Flang-Driver')
+  config.excludes.append('Flang-Driver','Frontend')
 
 # test_source_root: The root path where tests are located.
 config.test_source_root = os.path.dirname(__file__)
 
 # test_exec_root: The root path where tests should be run.
 config.test_exec_root = os.path.join(config.flang_obj_root, 'test')
 
 # Tweak the PATH to include the tools dir.

flang/tools/flang-driver/fc1_main.cpp

int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
 
   diagsBuffer->FlushDiagnostics(flang->getDiagnostics());
   if (!success)
     return 1;
 
   // Execute the frontend actions.
   success = ExecuteCompilerInvocation(flang.get());
 
+  // Delete output files to free Compiler Instance
+  flang->ClearOutputFiles(/*EraseFiles=*/false);
+
   return !success;
 }

flang/unittests/Frontend/CMakeLists.txt

 add_flang_unittest(FlangFrontendTests
   CompilerInstanceTest.cpp
+  InputOutputTest.cpp
 )
 
 target_link_libraries(FlangFrontendTests
   PRIVATE
   LLVMSupport
   clangBasic
   flangFrontend
   flangFrontendTool)

flang/unittests/Frontend/CompilerInstanceTest.cpp

 //===- unittests/Frontend/CompilerInstanceTest.cpp - CI 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 "gtest/gtest.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "clang/Basic/DiagnosticOptions.h"
 #include "clang/Driver/Options.h"
 #include "clang/Frontend/TextDiagnosticPrinter.h"
+#include "llvm/Support/FileSystem.h"
 #include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
 
 #include <filesystem>
 using namespace llvm;
 using namespace Fortran::frontend;
 
 namespace {
 
+TEST(CompilerInstance, SanityCheckForInputFile) {
+  // 1. Prepare the input to be stores in a buffer
+  // Create the file to be used by AllSources
+  // Flang function 'FortranAllSources.Open' needs a physical file
+  // and the full path to work with
+  const char *inputSource = "InputSourceFile";
+  std::string inputFilename = "buffer-file-test.f";
+  std::error_code ec;
+  std::unique_ptr<llvm::raw_fd_ostream> os{
+      new llvm::raw_fd_ostream(inputFilename, ec, llvm::sys::fs::OF_None)};
+  if (ec)
+    llvm::errs() << "Fail to create the file need by the test";
+  *(os) << inputSource;
+  os.reset();
+  std::string getFileFullPath = std::filesystem::current_path().c_str();
+  getFileFullPath = getFileFullPath + "/" + inputFilename;
+
+  // 2. Setting up the file/source manager for Compiler Instance
+  std::string buf;
+  llvm::raw_string_ostream error_stream{buf};
+  CompilerInstance compInst;
+  Fortran::parser::AllSources &allSources{compInst.GetAllSources()};
+  const Fortran::parser::SourceFile *sf;
+  sf = allSources.Open(getFileFullPath, error_stream);
+  llvm::ArrayRef<char> fileContent = sf->content();
+
+  // 3. Verifies the content of the buffer in SourceFile
+  // Check that the compiler instance was able to write
+  EXPECT_FALSE(fileContent.size() == 0);
+  EXPECT_TRUE(
+      llvm::StringRef(fileContent.data()).startswith("InputSourceFile"));
+
+  // 4. Delete file
+  llvm::sys::fs::remove(inputFilename);
+}
+
 TEST(CompilerInstance, AllowDiagnosticLogWithUnownedDiagnosticConsumer) {
   // 1. Set-up a basic DiagnosticConsumer
   std::string diagnosticOutput;
   llvm::raw_string_ostream diagnosticsOS(diagnosticOutput);
   auto diagPrinter = std::make_unique<clang::TextDiagnosticPrinter>(
       diagnosticsOS, new clang::DiagnosticOptions());
 
   // 2. Create a CompilerInstance (to manage a DiagnosticEngine)

flang/unittests/Frontend/InputOutputTest.cpp

+//===- unittests/Frontend/OutputStreamTest.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/FrontendOptions.h"
+#include "flang/FrontendTool/Utils.h"
+#include "llvm/Support/FileSystem.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+
+#include <filesystem>
+
+using namespace Fortran::frontend;
+
+namespace {
+
+TEST(FrontendOutputTests, TestInputOutputStreamOwned) {
+  // 1. Prepare the input file to be used by IO
+  // Create the file to be used by AllSources
+  // Flang function 'FortranAllSources.Open' needs a physical file
+  // and the full path to work with
+  std::string inputFilename = "io-file-test.f";
+  std::error_code ec;
+  std::unique_ptr<llvm::raw_fd_ostream> os{
+      new llvm::raw_fd_ostream(inputFilename, ec, llvm::sys::fs::OF_None)};
+  if (ec)
+    llvm::errs() << "Fail to create the file need by the test";
+  *(os) << "End Program arithmetic";
+  os.reset();
+  std::string getFileFullPath = std::filesystem::current_path().c_str();
+  getFileFullPath = getFileFullPath + "/" + inputFilename;
+
+  // 2. Prepare the compiler (Invocation + Instance)
+  CompilerInstance compInst;
+  compInst.CreateDiagnostics();
+  auto invocation = std::make_shared<CompilerInvocation>();
+  invocation->GetFrontendOpts().programAction_ = InputOutputTest;
+  compInst.SetInvocation(std::move(invocation));
+  compInst.GetFrontendOpts().inputs_.push_back(
+      FrontendInputFile(/*File=*/getFileFullPath, Language::Fortran));
+
+  // 3. 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));
+
+  // 4. Run the earlier defined FrontendAction
+  bool success = ExecuteCompilerInvocation(&compInst);
+
+  EXPECT_TRUE(success);
+  EXPECT_TRUE(!outputFileBuffer.empty());
+  EXPECT_TRUE(llvm::StringRef(outputFileBuffer.data())
+                  .startswith("End Program arithmetic"));
+
+  // 5. Remove files
+  compInst.ClearOutputFiles(/*EraseFiles=*/false);
+}
+} // namespace
 No newline at end of file