[flang][driver] Add support for -S and implement -c/-emit-obj

[awarzynski]

Summary

This patch adds support for:

• -S in Flang's compiler and frontend drivers

and implements (these options were already available as placeholders):

• -emit-obj in Flang's frontend driver and -c in Flang's compiler driver

The semantics of these options in Clang and Flang are identical.

The EmitObjAction frontend action is renamed as BackendAction. The
new name more accurately reflects the fact that this action will
primarily run the code-gen/backend pipeline in LLVM. It also makes more
sense as an action implementing both -emit-obj and -S (originally it
was just -emit-obj).

tripleName in FirContext.cpp is updated from fir.triple to
llvm.target_triple. The former was effectively ignored. The latter is
used when lowering from the LLVM dialect in MLIR to LLVM IR (i.e. it's
embedded in the generated LLVM IR module). The driver can then re-use
that when configuring the backend. With this change, the LLVM IR files
generated by e.g. tco will from now on contain the correct target
triple.

The code-gen.f90 test is replaced with code-gen-x86.f90 and
code-gen-aarch64.f90. With 2 seperate files we can verify that
--target is correctly taken into account. LIT configuration is updated
to enable e.g.:

! REQUIRES: aarch64-registered-target

[schweitz]

flang/lib/Frontend/FrontendActions.cpp

43

You'll want to keep in mind that some class names are overloaded between llvm and Fortran::xyz namespaces and even between Fortran::uvw and Fortran::xyz namespaces.

505

515

This assert comes after TM is dereferenced in the line above.

555

getTargetTriple() was already saved into theTriple variable above.

558

Do you want to assert on this RAII of TLII?

flang/lib/Optimizer/Support/FIRContext.cpp

19

Why is this being changed? This is a FIR specific attribute.

[rovka]

I'm having trouble building this on Windows on Arm. I'm still investigating if it's a problem with the patch or just growing pains on the WoA side :) I'll try to get to the bottom of it as soon as I can.

flang/lib/Frontend/FrontendActions.cpp

508

Shouldn't this be a diagnostic? People could be trying to compile a random IR file with a triple that's not registered.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

43

Thanks, I will revert this.

558

Any particular suggestion? I don't see anything that I could assert here.

flang/lib/Optimizer/Support/FIRContext.cpp

19

The driver assumes that when compiling a Fortran file, a valid triple will be present in the generated LLVM IR file. Currently, fir.tiple is just dropped and the generated LLVM IR module contains no triple. For -emit-obj/-S to work, we do need to make sure that a valid triple is actually there.

We could add logic to translate fir.triple to llvm.target_triple (in the FIR --> LLVM MLIR translation layer), but why bother if it's not used anywhere? Instead, Flang could use llvm.target_triple from the very beginning. This way, no extra functionality is needed (llvm.target_triple is preserved when translating from FIR to LLVM MLIR and then included in the generated LLVM IR module).

AFAIK, fir-triple is never used anywhere. In fact, it's already been removed from fir-dev.

[awarzynski]

Incorproate suggestions from Eric

[awarzynski]

Fix formatting and rebase

[awarzynski]

Update how target IR analysis passes are initialised (use TargetMachine::getTargetIRAnalysis() instead of calling the constructor directly).

[rovka]

This passes on Windows on Arm if you add a forward declaration for class PassInstrumentation here. This is necessary because otherwise clang picks up the PassInstrumentation from MLIR instead of the PassInstrumentation defined lower in the file.

For reference, this is the error I was seeing before:

C:\Work\diana.picus\llvm-project\llvm\include\llvm/IR/PassInstrumentation.h(145,16): warning: unqualified friend declaration referring to type outside of the nearest enclosing namespace is a Microsoft extension; add a nested name specifier [-Wmicrosoft-unqualified-friend]
  friend class PassInstrumentation;
               ^
               ::mlir::
C:\Work\diana.picus\llvm-project\llvm\include\llvm/IR/PassInstrumentation.h(292,33): error: 'AnalysesClearedCallbacks' is a private member of 'llvm::PassInstrumentationCallbacks'
      for (auto &C : Callbacks->AnalysesClearedCallbacks)
                                ^
C:\Work\diana.picus\llvm-project\llvm\include\llvm/IR/PassInstrumentation.h(173,7): note: declared private here
      AnalysesClearedCallbacks;

[awarzynski]

Add a forward declaration for class PassInstrumentation (thank you @rovka!)

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

508

Good point! However, I'm struggling to trigger this assert ATM and I don't want to issue a diagnostic if I can't test it. This will change once flang-new can consume LLVM IR files (soon). In the meantime, let me add a TODO. Hopefully we won't forget to elevate this to a proper diagnostic when the time is right :)

[rovka]

I don't have any other comments, I'll let Eric take it from here :)

flang/lib/Frontend/FrontendActions.cpp

508

TODO is fine for now, thanks.

[schweitz]

flang/lib/Frontend/FrontendActions.cpp

561

Got jumbled around somehow. TLII is allocated at line 559-560. Since you are checking allocations with assert in other places, why not here? TLII is immediately dereferenced on line 561, without an assertion check.

flang/lib/Optimizer/Support/FIRContext.cpp

19

Thanks for the update. I'm glad to see MLIR decided to use my module attribute trick here. :)

Given this, there is no reason to "block copy" the name of the attribute over to FIR. Just use the mlir::LLVM::LLVMDialect::getTargetTripleAttrName() method. The FIR attribute can then be retired and removed along with the setter and getter.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

561

Thanks for clarifying. One assert coming this way :)

flang/lib/Optimizer/Support/FIRContext.cpp

19

I wasn't aware of getTargetTripleAttrName, thanks! I will use that instead.

As for setTargetTriple and getTargetTriple, we'd need a bit more work to remove them. I suggest doing that in a separate patch.

[awarzynski]

• Got rid of tripleName
• Added an assert for the newly created TLII
• Rebased
• Added #includes missing after the rebase

[awarzynski]

Rebase on top of D120897

[awarzynski]

Rebase

[schweitz]

LGTM

clang/include/clang/Driver/Options.td

def Rpass_missed_EQ : Joined<["-"], "Rpass-missed=">, Group<R_value_Group>,
   HelpText<"Report missed transformations by optimization passes whose "
            "name matches the given POSIX regular expression">;
 def Rpass_analysis_EQ : Joined<["-"], "Rpass-analysis=">, Group<R_value_Group>,
   Flags<[CC1Option]>,
   HelpText<"Report transformation analysis from optimization passes whose "
            "name matches the given POSIX regular expression">;
 def R_Joined : Joined<["-"], "R">, Group<R_Group>, Flags<[CC1Option, CoreOption]>,
   MetaVarName<"<remark>">, HelpText<"Enable the specified remark">;
-def S : Flag<["-"], "S">, Flags<[NoXarchOption,CC1Option]>, Group<Action_Group>,
+def S : Flag<["-"], "S">, Flags<[NoXarchOption,CC1Option,FlangOption,FC1Option]>, Group<Action_Group>,
   HelpText<"Only run preprocess and compilation steps">;
 def Tbss : JoinedOrSeparate<["-"], "Tbss">, Group<T_Group>,
   MetaVarName<"<addr>">, HelpText<"Set starting address of BSS to <addr>">;
 def Tdata : JoinedOrSeparate<["-"], "Tdata">, Group<T_Group>,
   MetaVarName<"<addr>">, HelpText<"Set starting address of DATA to <addr>">;
 def Ttext : JoinedOrSeparate<["-"], "Ttext">, Group<T_Group>,
   MetaVarName<"<addr>">, HelpText<"Set starting address of TEXT to <addr>">;
 def T : JoinedOrSeparate<["-"], "T">, Group<T_Group>,

flang/include/flang/Frontend/FrontendActions.h

 class EmitMLIRAction : public CodeGenAction {
   void ExecuteAction() override;
 };
 
 class EmitLLVMAction : public CodeGenAction {
   void ExecuteAction() override;
 };
 
-class EmitObjAction : public CodeGenAction {
+class BackendAction : public CodeGenAction {
+public:
+  enum class BackendActionTy {
+    Backend_EmitAssembly, ///< Emit native assembly files
+    Backend_EmitObj ///< Emit native object files
+  };
+
+  BackendAction(BackendActionTy act) : action{act} {};
+
+private:
   void ExecuteAction() override;
+
+  BackendActionTy action;
 };
 
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDACTIONS_H

flang/include/flang/Frontend/FrontendOptions.h

enum ActionKind {
   EmitMLIR,
 
   /// Emit an .ll file
   EmitLLVM,
 
   /// Emit a .o file.
   EmitObj,
 
+  /// Emit a .s file.
+  EmitAssembly,
+
   /// Parse, unparse the parse-tree and output a Fortran source file
   DebugUnparse,
 
   /// Parse, unparse the parse-tree and output a Fortran source file, skip the
   /// semantic checks
   DebugUnparseNoSema,
 
   /// Parse, resolve the sybmols, unparse the parse-tree and then output a

flang/lib/Frontend/CMakeLists.txt

add_flang_library(flangFrontend
   LINK_LIBS
   FortranParser
   FortranSemantics
   FortranEvaluate
   FortranCommon
   FortranLower
   clangBasic
   clangDriver
+  LLVMAnalysis
+  LLVMTarget
   FIRDialect
   FIRSupport
   FIRBuilder
   FIRCodeGen
   FIRTransforms
   MLIRTransforms
   MLIRLLVMToLLVMIRTranslation
   MLIRSCFToControlFlow
   ${dialect_libs}
 
   LINK_COMPONENTS
   Option
   Support
   FrontendOpenACC
   FrontendOpenMP
 )

flang/lib/Frontend/CompilerInvocation.cpp

case clang::driver::options::OPT_emit_mlir:
       opts.programAction = EmitMLIR;
       break;
     case clang::driver::options::OPT_emit_llvm:
       opts.programAction = EmitLLVM;
       break;
     case clang::driver::options::OPT_emit_obj:
       opts.programAction = EmitObj;
       break;
+    case clang::driver::options::OPT_S:
+      opts.programAction = EmitAssembly;
+      break;
     case clang::driver::options::OPT_fdebug_unparse:
       opts.programAction = DebugUnparse;
       break;
     case clang::driver::options::OPT_fdebug_unparse_no_sema:
       opts.programAction = DebugUnparseNoSema;
       break;
     case clang::driver::options::OPT_fdebug_unparse_with_symbols:
       opts.programAction = DebugUnparseWithSymbols;

flang/lib/Frontend/FrontendActions.cpp

 #include "flang/Semantics/runtime-type-info.h"
 #include "flang/Semantics/semantics.h"
 #include "flang/Semantics/unparse-with-symbols.h"
 
 #include "mlir/IR/Dialect.h"
 #include "mlir/Pass/PassManager.h"
 #include "mlir/Target/LLVMIR/ModuleTranslation.h"
 #include "llvm/ADT/StringRef.h"
+#include "llvm/IR/LegacyPassManager.h"
+#include "llvm/MC/TargetRegistry.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/ErrorHandling.h"
+#include "llvm/Target/TargetMachine.h"
 #include <clang/Basic/Diagnostic.h>
 #include <memory>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//
 // Custom BeginSourceFileAction
 //===----------------------------------------------------------------------===//
 bool PrescanAction::BeginSourceFileAction() { return RunPrescan(); }
 
 bool PrescanAndParseAction::BeginSourceFileAction() {
   return RunPrescan() && RunParse();
 }
void CodeGenAction::GenerateLLVMIR() {
   fir::support::loadDialects(*mlirCtx);
   fir::support::registerLLVMTranslation(*mlirCtx);
 
   // Set-up the MLIR pass manager
   mlir::PassManager pm(mlirCtx.get(), mlir::OpPassManager::Nesting::Implicit);
 
   pm.addPass(std::make_unique<Fortran::lower::VerifierPass>());
   pm.enableVerifier(/*verifyPasses=*/true);
-  mlir::PassPipelineCLParser passPipeline("", "Compiler passes to run");
 
   // Create the pass pipeline
   fir::createMLIRToLLVMPassPipeline(pm);
 
   // Run the pass manager
   if (!mlir::succeeded(pm.run(*mlirModule))) {
     unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "Lowering to LLVM IR failed");
unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "failed to create the output file");
     ci.diagnostics().Report(diagID);
     return;
   }
 
   mlirModule->print(*os);
 }
 
-void EmitObjAction::ExecuteAction() {
+void BackendAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
-  unsigned DiagID = ci.diagnostics().getCustomDiagID(
-      clang::DiagnosticsEngine::Error, "code-generation is not available yet");
-  ci.diagnostics().Report(DiagID);
+  // Generate an LLVM module if it's not already present (it will already be
+  // present if the input file is an LLVM IR/BC file).
+  if (!llvmModule)
+    GenerateLLVMIR();
+
+  // Create `Target`
+  std::string error;
+  const std::string &theTriple = llvmModule->getTargetTriple();
+  const llvm::Target *theTarget =
+      llvm::TargetRegistry::lookupTarget(theTriple, error);
+  // TODO: Make this a diagnostic once `flang-new` can consume LLVM IR files
+  // (in which users could use unsupported triples)
+  assert(theTarget && "Failed to create Target");
+
+  // Create `TargetMachine`
+  std::unique_ptr<llvm::TargetMachine> TM;
+  TM.reset(theTarget->createTargetMachine(
+      theTriple, /*CPU=*/"", /*Features=*/"", llvm::TargetOptions(), None));
+  assert(TM && "Failed to create TargetMachine");
+  llvmModule->setDataLayout(TM->createDataLayout());
+
+  // If the output stream is a file, generate it and define the corresponding
+  // output stream. If a pre-defined output stream is available, we will use
+  // that instead.
+  //
+  // NOTE: `os` is a smart pointer that will be destroyed at the end of this
+  // method. However, it won't be written to until `CodeGenPasses` is
+  // destroyed. By defining `os` before `CodeGenPasses`, we make sure that the
+  // output stream won't be destroyed before it is written to. This only
+  // applies when an output file is used (i.e. there is no pre-defined output
+  // stream).
+  // TODO: Revisit once the new PM is ready (i.e. when `CodeGenPasses` is
+  // updated to use it).
+  std::unique_ptr<llvm::raw_pwrite_stream> os;
+  if (ci.IsOutputStreamNull()) {
+    // Get the output buffer/file
+    switch (action) {
+    case BackendActionTy::Backend_EmitAssembly:
+      os = ci.CreateDefaultOutputFile(
+          /*Binary=*/false, /*InFile=*/GetCurrentFileOrBufferName(), "s");
+      break;
+    case BackendActionTy::Backend_EmitObj:
+      os = ci.CreateDefaultOutputFile(
+          /*Binary=*/true, /*InFile=*/GetCurrentFileOrBufferName(), "o");
+      break;
+    }
+    if (!os) {
+      unsigned diagID = ci.diagnostics().getCustomDiagID(
+          clang::DiagnosticsEngine::Error, "failed to create the output file");
+      ci.diagnostics().Report(diagID);
+      return;
+    }
+  }
+
+  // Create an LLVM code-gen pass pipeline. Currently only the legacy pass
+  // manager is supported.
+  // TODO: Switch to the new PM once it's available in the backend.
+  llvm::legacy::PassManager CodeGenPasses;
+  CodeGenPasses.add(
+      createTargetTransformInfoWrapperPass(TM->getTargetIRAnalysis()));
+  llvm::Triple triple(theTriple);
+  std::unique_ptr<llvm::TargetLibraryInfoImpl> TLII =
+      std::make_unique<llvm::TargetLibraryInfoImpl>(triple);
+  CodeGenPasses.add(new llvm::TargetLibraryInfoWrapperPass(*TLII));
+
+  llvm::CodeGenFileType cgft = (action == BackendActionTy::Backend_EmitAssembly)
+      ? llvm::CodeGenFileType::CGFT_AssemblyFile
+      : llvm::CodeGenFileType::CGFT_ObjectFile;
+  if (TM->addPassesToEmitFile(CodeGenPasses,
+          ci.IsOutputStreamNull() ? *os : ci.GetOutputStream(), nullptr,
+          cgft)) {
+    unsigned diagID =
+        ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Error,
+            "emission of this file type is not supported");
+    ci.diagnostics().Report(diagID);
+    return;
+  }
+
+  // Run the code-gen passes
+  CodeGenPasses.run(*llvmModule);
 }
 
 void InitOnlyAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   unsigned DiagID =
       ci.diagnostics().getCustomDiagID(clang::DiagnosticsEngine::Warning,
           "Use `-init-only` for testing purposes only");
   ci.diagnostics().Report(DiagID);
 }
 
 void PluginParseTreeAction::ExecuteAction() {}

flang/lib/FrontendTool/ExecuteCompilerInvocation.cpp

case PrintPreprocessedInput:
     return std::make_unique<PrintPreprocessedAction>();
   case ParseSyntaxOnly:
     return std::make_unique<ParseSyntaxOnlyAction>();
   case EmitMLIR:
     return std::make_unique<EmitMLIRAction>();
   case EmitLLVM:
     return std::make_unique<EmitLLVMAction>();
   case EmitObj:
-    return std::make_unique<EmitObjAction>();
+    return std::make_unique<BackendAction>(
+        BackendAction::BackendActionTy::Backend_EmitObj);
+  case EmitAssembly:
+    return std::make_unique<BackendAction>(
+        BackendAction::BackendActionTy::Backend_EmitAssembly);
   case DebugUnparse:
     return std::make_unique<DebugUnparseAction>();
   case DebugUnparseNoSema:
     return std::make_unique<DebugUnparseNoSemaAction>();
   case DebugUnparseWithSymbols:
     return std::make_unique<DebugUnparseWithSymbolsAction>();
   case DebugDumpSymbols:
     return std::make_unique<DebugDumpSymbolsAction>();

flang/lib/Optimizer/Support/FIRContext.cpp

 //===----------------------------------------------------------------------===//
 
 #include "flang/Optimizer/Support/FIRContext.h"
 #include "flang/Optimizer/Support/KindMapping.h"
 #include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/BuiltinOps.h"
 #include "llvm/Support/Host.h"
 
-static constexpr const char *tripleName = "fir.triple";
+static constexpr const char *tripleName = "llvm.target_triple";
 
 void fir::setTargetTriple(mlir::ModuleOp mod, llvm::StringRef triple) {
   auto target = fir::determineTargetTriple(triple);
   mod->setAttr(tripleName, mlir::StringAttr::get(mod.getContext(), target));
 }
 
 llvm::Triple fir::getTargetTriple(mlir::ModuleOp mod) {
   if (auto target = mod->getAttrOfType<mlir::StringAttr>(tripleName))

flang/test/CMakeLists.txt

configure_lit_site_cfg(
   MAIN_CONFIG
   ${CMAKE_CURRENT_SOURCE_DIR}/NonGtestUnit/lit.cfg.py
 )
 
 set(FLANG_TEST_PARAMS
   flang_site_config=${CMAKE_CURRENT_BINARY_DIR}/lit.site.cfg.py)
 
 set(FLANG_TEST_DEPENDS
-  flang-new llvm-config FileCheck count not module_files fir-opt tco bbc
+  flang-new llvm-config FileCheck count not module_files fir-opt tco bbc llvm-objdump
 )
 
 if (FLANG_INCLUDE_TESTS)
   if (FLANG_GTEST_AVAIL)
     list(APPEND FLANG_TEST_DEPENDS FlangUnitTests)
   endif()
 endif()
 

flang/test/Driver/code-gen-aarch64.f90

+! Test -emit-obj (X86)
+
+! REQUIRES: aarch64-registered-target, x86-registered-target
+
+!-------------
+! RUN COMMANDS
+!-------------
+! RUN: rm -f %t.o
+! RUN: %flang_fc1 -emit-obj -triple aarch64-unknown-linux-gnu %s -o %t.o
+! RUN: llvm-objdump --triple aarch64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=CORRECT_TRIPLE
+! RUN: rm -f %t.o
+! RUN: %flang -c --target=aarch64-unknown-linux-gnu %s -o %t.o
+! RUN: llvm-objdump --triple aarch64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=CORRECT_TRIPLE
+
+! RUN: %flang -c --target=aarch64-unknown-linux-gnu %s -o %t.o
+! RUN: llvm-objdump --triple x86_64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=INCORRECT_TRIPLE
+
+!----------------
+! EXPECTED OUTPUT
+!----------------
+! CORRECT_TRIPLE-LABEL: <_QQmain>:
+! CORRECT_TRIPLE-NEXT:    ret
+
+! When incorrect triple is used to disassemble, there won't be a ret instruction at all.
+! INCORRECT_TRIPLE-LABEL: <_QQmain>:
+! INCORRECT_TRIPLE-NOT:   ret
+
+!------
+! INPUT
+!------
+end program

flang/test/Driver/code-gen-x86.f90

+! Test -emit-obj (X86)
+
+! REQUIRES: x86-registered-target, aarch64-registered-target
+! UNSUPPORTED: darwin, macos
+
+!-------------
+! RUN COMMANDS
+!-------------
+! RUN: rm -f %t.o
+! RUN: %flang_fc1 -triple x86_64-unknown-linux-gnu -emit-obj %s -o %t.o
+! RUN: llvm-objdump --triple x86_64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=CORRECT_TRIPLE
+! RUN: rm -f %t.o
+! RUN: %flang --target=x86_64-unknown-linux-gnu -c %s -o %t.o
+! RUN: llvm-objdump --triple x86_64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=CORRECT_TRIPLE
+
+! RUN: %flang -c --target=x86_64-unknown-linux-gnu %s -o %t.o
+! RUN: llvm-objdump --triple aarch64-unknown-linux-gnu --disassemble-all %t.o | FileCheck %s --check-prefix=INCORRECT_TRIPLE
+
+!----------------
+! EXPECTED OUTPUT
+!----------------
+! CORRECT_TRIPLE-LABEL: <_QQmain>:
+! CORRECT_TRIPLE-NEXT:    retq
+
+! When incorrect triple is used to disassemble, there won't be a ret(q) instruction at all.
+! INCORRECT_TRIPLE-LABEL: <_QQmain>:
+! INCORRECT_TRIPLE-NOT:   ret
+
+!------
+! INPUT
+!------
+end program

flang/test/Driver/code-gen.f90

-! Although code-generation is not yet available, we do have frontend actions
-! that correspond to `-c` and `-emit-obj`. For now these actions are just a
-! placeholder and running them leads to a driver error. This test makes sure
-! that these actions are indeed run (rather than `-c` or `-emit-obj` being
-! rejected earlier).
-! TODO: Replace this file with a proper test once code-generation is available.
-
-!-----------
-! RUN LINES
-!-----------
-! RUN: not %flang %s 2>&1 | FileCheck %s --check-prefix=ERROR
-! RUN: not %flang -c %s 2>&1 | FileCheck %s --check-prefix=ERROR
-! RUN: not %flang -emit-obj %s 2>&1 | FileCheck %s --check-prefix=ERROR
-! RUN: not %flang -fc1 -emit-obj %s 2>&1 | FileCheck %s --check-prefix=ERROR
-
-!-----------------------
-! EXPECTED OUTPUT
-!-----------------------
-! ERROR: code-generation is not available yet

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

 ! CHECK-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! CHECK-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! CHECK-NEXT: -o <file> Write output to <file>
 ! CHECK-NEXT: -pedantic              Warn on language extensions
 ! CHECK-NEXT: -print-effective-triple Print the effective target triple
 ! CHECK-NEXT: -print-target-triple    Print the normalized target triple
 ! CHECK-NEXT: -P                     Disable linemarker output in -E mode
 ! CHECK-NEXT: -std=<value>           Language standard to compile for
+! CHECK-NEXT: -S                     Only run preprocess and compilation steps
 ! CHECK-NEXT: --target=<value>        Generate code for the given target
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 ! CHECK-NEXT: -W<warning>            Enable the specified warning
 ! CHECK-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG DRIVER (flang-new)

flang/test/Driver/driver-help.f90

 ! HELP-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! HELP-NEXT: -o <file>              Write output to <file>
 ! HELP-NEXT: -pedantic              Warn on language extensions
 ! HELP-NEXT: -print-effective-triple Print the effective target triple
 ! HELP-NEXT: -print-target-triple    Print the normalized target triple
 ! HELP-NEXT: -P                     Disable linemarker output in -E mode
 ! HELP-NEXT: -std=<value>           Language standard to compile for
+! HELP-NEXT: -S                     Only run preprocess and compilation steps
 ! HELP-NEXT: --target=<value>       Generate code for the given target
 ! HELP-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-NEXT: --version              Print version information
 ! HELP-NEXT: -W<warning>            Enable the specified warning
 ! HELP-NEXT: -Xflang <arg>          Pass <arg> to the flang compiler
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang -fc1)

 ! HELP-FC1-NEXT: -module-dir <dir>      Put MODULE files in <dir>
 ! HELP-FC1-NEXT: -module-suffix <suffix> Use <suffix> as the suffix for module files (the default value is `.mod`)
 ! HELP-FC1-NEXT: -nocpp                 Disable predefined and command line preprocessor macros
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -pedantic              Warn on language extensions
 ! HELP-FC1-NEXT: -plugin <name>         Use the named plugin action instead of the default action (use "help" to list available options)
 ! HELP-FC1-NEXT: -P                     Disable linemarker output in -E mode
 ! HELP-FC1-NEXT: -std=<value>           Language standard to compile for
+! HELP-FC1-NEXT: -S                     Only run preprocess and compilation steps
 ! HELP-FC1-NEXT: -test-io               Run the InputOuputTest action. Use for development and testing only.
 ! HELP-FC1-NEXT: -triple <value>        Specify target triple (e.g. i686-apple-darwin9)
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 ! HELP-FC1-NEXT: -W<warning>            Enable the specified warning
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Driver/emit-asm-aarch64.f90

+! Test -S (AArch64)
+
+! REQUIRES: aarch64-registered-target
+
+!-------------
+! RUN COMMANDS
+!-------------
+! RUN: %flang_fc1 -S -triple aarch64-unknown-linux-gnu %s -o - | FileCheck %s
+! RUN: %flang -S -target aarch64-unknown-linux-gnu %s -o - | FileCheck %s
+
+!----------------
+! EXPECTED OUTPUT
+!----------------
+! CHECK-LABEL: _QQmain:
+! CHECK-NEXT: .Lfunc_begin0:
+! CHECK: ret
+
+!------
+! INPUT
+!------
+end program

flang/test/Driver/emit-asm-x86.f90

+! Test -S (X86)
+
+! REQUIRES: x86-registered-target
+
+!-------------
+! RUN COMMANDS
+!-------------
+! RUN: %flang_fc1 -S -triple x86_64-unknown-linux-gnu %s -o - | FileCheck %s
+! RUN: %flang -S -target x86_64-unknown-linux-gnu %s -o - | FileCheck %s
+
+!----------------
+! EXPECTED OUTPUT
+!----------------
+! CHECK-LABEL: _QQmain:
+! CHECK-NEXT: .Lfunc_begin0:
+! CHECK: ret
+
+!------
+! INPUT
+!------
+end program

flang/test/Driver/syntax-only.f90

 ! Verify that the driver correctly processes `-fsyntax-only`.
 !
 ! By default, the compiler driver (`flang`) will create actions/phases to
 ! generate machine code (i.e. object files). The `-fsyntax-only` flag is a
 ! "phase-control" flag that controls this behavior and makes the driver stop
 ! once the semantic checks have been run. The frontend driver (`flang -fc1`)
 ! runs `-fsyntax-only` by default (i.e. that's the default action), so the flag
 ! can be skipped.
 
 !-----------
 ! RUN LINES
 !-----------
 ! RUN: %flang -fsyntax-only %s 2>&1 | FileCheck %s --allow-empty
 ! RUN: %flang_fc1 %s 2>&1 | FileCheck %s --allow-empty
 
-! RUN: not %flang  %s 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
-! RUN: not %flang_fc1 -emit-obj %s 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
+! RUN: rm -rf %t/non-existent-dir/
+! RUN: not %flang -c %s -o %t/non-existent-dir/syntax-only.o 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
+! RUN: not %flang_fc1 -emit-obj %s -o %t/non-existent-dir/syntax-only.o 2>&1 | FileCheck %s --check-prefix=NO_FSYNTAX_ONLY
 
 !-----------------
 ! EXPECTED OUTPUT
 !-----------------
 ! CHECK-NOT: error
-! NO_FSYNTAX_ONLY: error: code-generation is not available yet
+! NO_FSYNTAX_ONLY: error: failed to create the output file
 
 !-------
 ! INPUT
 !-------
 end program

flang/test/Fir/target-rewrite-triple.fir

 // RUN: fir-opt --target-rewrite %s | FileCheck %s --check-prefix=UNCHANGED
 // RUN: fir-opt --target-rewrite="target=x86_64-unknown-linux-gnu" %s | FileCheck %s --check-prefix=CHANGED
 
-// UNCHANGED: fir.triple = "aarch64-unknown-linux-gnu"
-// CHANGED: fir.triple = "x86_64-unknown-linux-gnu"
-// CHANGED-NOT: fir.triple = "aarch64-unknown-linux-gnu"
-module attributes {fir.triple = "aarch64-unknown-linux-gnu"}  {
+// UNCHANGED: llvm.target_triple = "aarch64-unknown-linux-gnu"
+// CHANGED: llvm.target_triple = "x86_64-unknown-linux-gnu"
+// CHANGED-NOT: llvm.target_triple = "aarch64-unknown-linux-gnu"
+module attributes {llvm.target_triple = "aarch64-unknown-linux-gnu"}  {
   func @dummyfunc() -> () {
     return
   }
 }
 

flang/test/lit.cfg.py

 config.substitutions.append(('%pluginext', config.llvm_plugin_ext))
 
 llvm_config.use_default_substitutions()
 
 # ask llvm-config about asserts
 llvm_config.feature_config(
     [('--assertion-mode', {'ON': 'asserts'})])
 
+# Targets
+config.targets = frozenset(config.targets_to_build.split())
+for arch in config.targets_to_build.split():
+    config.available_features.add(arch.lower() + '-registered-target')
+
 # excludes: A list of directories to exclude from the testsuite. The 'Inputs'
 # subdirectories contain auxiliary inputs for various tests in their parent
 # directories.
 config.excludes = ['Inputs', 'CMakeLists.txt', 'README.txt', 'LICENSE.txt']
 
 # If the flang examples are built, add examples to the config
 if config.flang_examples:
     config.available_features.add('examples')

flang/test/lit.site.cfg.py.in

 config.flang_intrinsic_modules_dir = "@FLANG_INTRINSIC_MODULES_DIR@"
 config.flang_llvm_tools_dir = "@CMAKE_BINARY_DIR@/bin"
 config.flang_lib_dir = "@CMAKE_BINARY_DIR@/lib"
 config.flang_examples = @FLANG_BUILD_EXAMPLES@
 config.python_executable = "@PYTHON_EXECUTABLE@"
 config.flang_standalone_build = @FLANG_STANDALONE_BUILD@
 config.has_plugins = @LLVM_ENABLE_PLUGINS@
 config.cc = "@CMAKE_C_COMPILER@"
+config.targets_to_build = "@TARGETS_TO_BUILD@"
 
 # Support substitution of the tools_dir with user parameters. This is
 # used when we can't determine the tool dir at configuration time.
 try:
     config.llvm_tools_dir = config.llvm_tools_dir % lit_config.params
     config.flang_tools_dir = config.flang_tools_dir % lit_config.params
     config.llvm_shlib_dir = config.llvm_shlib_dir % lit_config.params
 except KeyError:

flang/tools/flang-driver/fc1_main.cpp

 #include "flang/Frontend/CompilerInstance.h"
 #include "flang/Frontend/CompilerInvocation.h"
 #include "flang/Frontend/TextDiagnosticBuffer.h"
 #include "flang/FrontendTool/Utils.h"
 #include "clang/Driver/DriverDiagnostic.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
+#include "llvm/Support/TargetSelect.h"
 
 #include <cstdio>
 
 using namespace Fortran::frontend;
 
 int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
   // Create CompilerInstance
   std::unique_ptr<CompilerInstance> flang(new CompilerInstance());
int fc1_main(llvm::ArrayRef<const char *> argv, const char *argv0) {
   llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> diagID(
       new clang::DiagnosticIDs());
   llvm::IntrusiveRefCntPtr<clang::DiagnosticOptions> diagOpts =
       new clang::DiagnosticOptions();
   clang::DiagnosticsEngine diags(diagID, &*diagOpts, diagsBuffer);
   bool success =
       CompilerInvocation::CreateFromArgs(flang->invocation(), argv, diags);
 
+  // Initialize targets first, so that --version shows registered targets.
+  llvm::InitializeAllTargets();
+  llvm::InitializeAllTargetMCs();
+  llvm::InitializeAllAsmPrinters();
+
   diagsBuffer->FlushDiagnostics(flang->diagnostics());
 
   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

+set(LLVM_LINK_COMPONENTS
+  ${LLVM_TARGETS_TO_BUILD}
+)
+
 add_flang_unittest(FlangFrontendTests
   CompilerInstanceTest.cpp
   FrontendActionTest.cpp
 )
 
 target_link_libraries(FlangFrontendTests
   PRIVATE
   clangBasic
   flangFrontend
   flangFrontendTool
   FortranParser
   FortranSemantics
   FortranCommon
   FortranEvaluate
 )

flang/unittests/Frontend/FrontendActionTest.cpp

 //===- 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 "gtest/gtest.h"
 
 using namespace Fortran::frontend;
 
 namespace {
 
TEST_F(FrontendActionTest, EmitLLVM) {
 
   // Validate the expected output.
   EXPECT_TRUE(success);
   EXPECT_TRUE(!outputFileBuffer.empty());
 
   EXPECT_TRUE(llvm::StringRef(outputFileBuffer.data())
                   .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_.invocation().frontendOpts().programAction = EmitAssembly;
+  compInst_.invocation().preprocessorOpts().noReformat = true;
+
+  // Initialise LLVM backend
+  llvm::InitializeAllTargets();
+  llvm::InitializeAllTargetMCs();
+  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_.set_outputStream(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()).contains("_QQmain"));
+}
 } // namespace

llvm/include/llvm/IR/PassInstrumentation.h

 #include "llvm/ADT/StringMap.h"
 #include <type_traits>
 #include <vector>
 
 namespace llvm {
 
 class PreservedAnalyses;
 class StringRef;
+// This forward declaration is required to avoid clashes with a similarly named
+// class in other sub-projects (e.g. MLIR).
+class PassInstrumentation;
 
 /// This class manages callbacks registration, as well as provides a way for
 /// PassInstrumentation to pass control to the registered callbacks.
 class PassInstrumentationCallbacks {
 public:
   // Before/After callbacks accept IRUnits whenever appropriate, so they need
   // to take them as constant pointers, wrapped with llvm::Any.
   // For the case when IRUnit has been invalidated there is a different