[flang][driver] Add support for consuming LLVM IR/BC files

[awarzynski]

Summary

This change is mostly about making sure that Flang's driver recognises
LLVM IR and BC as supported as supported file formats. To this end,
isFortran is extended and renamed as isSupportedByFlang (the latter
better reflects the new functionality).

Some new tests are added to verify that the target triple is overridden
by the frontend driver's default or the value specified with -triple.
Strictly speaking, this is not a functionality that's added here.
However, this patch enables us to write such tests and hence I'm
including them here.

Depends on D124664
Depends on D124665

[rovka]

A few nits, but otherwise LGTM.

flang/lib/Frontend/FrontendActions.cpp

86

Nit: Should we assert that the language is Language::Fortran at this point?

flang/test/Driver/emit-asm-from-llvm-bc.ll

3

4

10

Have you tried %basename_t.bc instead? You might be able to skip all the rms then...

flang/test/Driver/emit-asm-from-llvm.ll

2

3

4

flang/test/Driver/override-triple.ll

21

[awarzynski]

Thanks for the review @rovka!

flang/lib/Frontend/FrontendActions.cpp

86

No harm in doing so 👍 !

flang/test/Driver/emit-asm-from-llvm-bc.ll

10

IIUC, the only difference between %t.bcand %basename_t.bc is that former contains a directory name and the file extension and latter does not. In either case, LIT won't delete it :(

I like %t a bit more as this way we make sure that the output lands in the right temporary directory.

[awarzynski]

Add an assert, make some editorial changes in comments

[awarzynski]

Rebase on top of main

clang/include/clang/Driver/Types.h

#undef TYPE
   /// canLipoType - Is this type acceptable as the output of a
   /// universal build (currently, just the Nothing, Image, and Object
   /// types).
   bool canLipoType(ID Id);
 
   /// isAcceptedByClang - Can clang handle this input type.
   bool isAcceptedByClang(ID Id);
 
+  /// isAcceptedByFlang - Can flang handle this input type.
+  bool isAcceptedByFlang(ID Id);
+
   /// isDerivedFromC - Is the input derived from C.
   ///
   /// That is, does the lexer follow the rules of
   /// TokenConcatenation::AvoidConcat. If this is the case, the preprocessor may
   /// add and remove whitespace between tokens. Used to determine whether the
   /// input can be processed by -fminimize-whitespace.
   bool isDerivedFromC(ID Id);
 
#undef TYPE
   bool isHIP(ID Id);
 
   /// isObjC - Is this an "ObjC" input (Obj-C and Obj-C++ sources and headers).
   bool isObjC(ID Id);
 
   /// isOpenCL - Is this an "OpenCL" input.
   bool isOpenCL(ID Id);
 
-  /// isFortran - Is this a Fortran input.
-  bool isFortran(ID Id);
-
   /// isSrcFile - Is this a source file, i.e. something that still has to be
   /// preprocessed. The logic behind this is the same that decides if the first
   /// compilation phase is a preprocessing one.
   bool isSrcFile(ID Id);
 
   /// lookupTypeForExtension - Lookup the type to use for the file
   /// extension \p Ext.
   ID lookupTypeForExtension(llvm::StringRef Ext);

clang/lib/Driver/Driver.cpp

if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
     return false;
 
   return true;
 }
 
 bool Driver::ShouldUseFlangCompiler(const JobAction &JA) const {
   // Say "no" if there is not exactly one input of a type flang understands.
   if (JA.size() != 1 ||
-      !types::isFortran((*JA.input_begin())->getType()))
+      !types::isAcceptedByFlang((*JA.input_begin())->getType()))
     return false;
 
   // And say "no" if this is not a kind of action flang understands.
-  if (!isa<PreprocessJobAction>(JA) && !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
+  if (!isa<PreprocessJobAction>(JA) && !isa<CompileJobAction>(JA) &&
+      !isa<BackendJobAction>(JA))
     return false;
 
   return true;
 }
 
 bool Driver::ShouldEmitStaticLibrary(const ArgList &Args) const {
   // Only emit static library if the flag is set explicitly.
   if (Args.hasArg(options::OPT_emit_static_lib))

clang/lib/Driver/Types.cpp

bool types::isAcceptedByClang(ID Id) {
   case TY_CXXModule: case TY_PP_CXXModule:
   case TY_AST: case TY_ModuleFile: case TY_PCH:
   case TY_LLVM_IR: case TY_LLVM_BC:
   case TY_API_INFO:
     return true;
   }
 }
 
+bool types::isAcceptedByFlang(ID Id) {
+  switch (Id) {
+  default:
+    return false;
+
+  case TY_Fortran:
+  case TY_PP_Fortran:
+    return true;
+  case TY_LLVM_IR:
+  case TY_LLVM_BC:
+    return true;
+  }
+}
+
 bool types::isDerivedFromC(ID Id) {
   switch (Id) {
   default:
     return false;
 
   case TY_PP_C:
   case TY_C:
   case TY_CL:
bool types::isHIP(ID Id) {
 
   case TY_HIP:
   case TY_PP_HIP:
   case TY_HIP_DEVICE:
     return true;
   }
 }
 
-bool types::isFortran(ID Id) {
-  switch (Id) {
-  default:
-    return false;
-
-  case TY_Fortran: case TY_PP_Fortran:
-    return true;
-  }
-}
-
 bool types::isSrcFile(ID Id) {
   return Id != TY_Object && getPreprocessedType(Id) != TY_INVALID;
 }
 
 types::ID types::lookupTypeForExtension(llvm::StringRef Ext) {
   return llvm::StringSwitch<types::ID>(Ext)
            .Case("c", TY_C)
            .Case("C", TY_CXX)

flang/lib/Frontend/CMakeLists.txt

add_flang_library(flangFrontend
   MLIRTransforms
   MLIRLLVMToLLVMIRTranslation
   MLIRSCFToControlFlow
   ${dialect_libs}
 
   LINK_COMPONENTS
   Passes
   Analysis
+  IRReader
   Option
   Support
   Target
   FrontendOpenACC
   FrontendOpenMP
 )

flang/lib/Frontend/FrontendActions.cpp

bool PrescanAndSemaDebugAction::BeginSourceFileAction() {
   // from exiting early (i.e. in the presence of semantic errors). We should
   // never do this in actions intended for end-users or otherwise regular
   // compiler workflows!
   return RunPrescan() && RunParse() && (RunSemanticChecks() || true) &&
       (GenerateRtTypeTables() || true);
 }
 
 bool CodeGenAction::BeginSourceFileAction() {
+  llvmCtx = std::make_unique<llvm::LLVMContext>();
+
+  // If the input is an LLVM file, just parse it and return.
+  if (this->currentInput().kind().GetLanguage() == Language::LLVM_IR) {
+    llvm::SMDiagnostic err;
+    llvmModule = llvm::parseIRFile(currentInput().file(), err, *llvmCtx);
+
+    return (nullptr != llvmModule);
+  }
+
+  // Otherwise, generate an MLIR module from the input Fortran source
+  assert(currentInput().kind().GetLanguage() == Language::Fortran &&
+         "Invalid input type - expecting a Fortran file");
   bool res = RunPrescan() && RunParse() && RunSemanticChecks();
   if (!res)
     return res;
 
   CompilerInstance &ci = this->instance();
 
   // Load the MLIR dialects required by Flang
   mlir::DialectRegistry registry;
void CodeGenAction::GenerateLLVMIR() {
   if (!mlir::succeeded(pm.run(*mlirModule))) {
     unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "Lowering to LLVM IR failed");
     ci.diagnostics().Report(diagID);
   }
 
   // Translate to LLVM IR
   llvm::Optional<llvm::StringRef> moduleName = mlirModule->getName();
-  llvmCtx = std::make_unique<llvm::LLVMContext>();
   llvmModule = mlir::translateModuleToLLVMIR(
       *mlirModule, *llvmCtx, moduleName ? *moduleName : "FIRModule");
 
   if (!llvmModule) {
     unsigned diagID = ci.diagnostics().getCustomDiagID(
         clang::DiagnosticsEngine::Error, "failed to create the LLVM module");
     ci.diagnostics().Report(diagID);
     return;

flang/lib/Frontend/FrontendOptions.cpp

return suffix == "F" || suffix == "FOR" || suffix == "fpp" ||
       suffix == "FPP" || suffix == "F90" || suffix == "F95" ||
       suffix == "F03" || suffix == "F08" || suffix == "F18";
 }
 
 InputKind FrontendOptions::GetInputKindForExtension(llvm::StringRef extension) {
   if (isFixedFormSuffix(extension) || isFreeFormSuffix(extension)) {
     return Language::Fortran;
   }
+
+  if (extension == "bc" || extension == "ll")
+    return Language::LLVM_IR;
+
   return Language::Unknown;
 }

flang/test/Driver/emit-asm-from-llvm-bc.ll

+; Verify that the driver can consume LLVM BC files. The expected assembly is
+; fairly generic (tested on AArch64 and X86_64), but we may need to tweak when
+; testing on other platforms. Note that the actual output doesn't matter as
+; long as it's in Assembly format.
+
+;-------------
+; RUN COMMANDS
+;-------------
+; RUN: rm -f %t.bc
+; RUN: %flang_fc1 -emit-llvm-bc %s -o %t.bc
+; RUN: %flang_fc1 -S -o - %t.bc | FileCheck %s
+; RUN: rm -f %t.bc
+
+; RUN: rm -f %t.bc
+; RUN: %flang -c -emit-llvm %s -o %t.bc
+; RUN: %flang -S -o - %t.bc | FileCheck %s
+; RUN: rm -f %t.bc
+
+;----------------
+; EXPECTED OUTPUT
+;----------------
+; CHECK-LABEL: foo:
+; CHECK: ret
+
+;------
+; INPUT
+;------
+define void @foo() {
+  ret void
+}

flang/test/Driver/emit-asm-from-llvm.ll

+; Verify that the driver can consume LLVM IR files. The expected assembly is
+; fairly generic (verified on AArch64 and X86_64), but we may need to tweak when
+; testing on other platforms. Note that the actual output doesn't matter
+; as long as it's in Assembly format.
+
+;-------------
+; RUN COMMANDS
+;-------------
+; RUN: %flang_fc1 -S %s -o - | FileCheck %s
+; RUN: %flang -S  %s -o - | FileCheck %s
+
+;----------------
+; EXPECTED OUTPUT
+;----------------
+; CHECK-LABEL: foo:
+; CHECK: ret
+
+;------
+; INPUT
+;------
+define void @foo() {
+  ret void
+}

flang/test/Driver/missing-triple.ll

+; Verify that the module triple is overridden by the driver - even when the
+; module triple is missing.
+; NOTE: At the time of writing, the tested behaviour was consistent with Clang
+
+;-------------
+; RUN COMMANDS
+;-------------
+; RUN: %flang_fc1 -S %s -o - 2>&1 | FileCheck %s
+; RUN: %flang -S  %s -o - 2>&1 | FileCheck %s
+
+;----------------
+; EXPECTED OUTPUT
+;----------------
+; CHECK: warning: overriding the module target triple with {{.*}}
+
+;------
+; INPUT
+;------
+define void @foo() {
+  ret void
+}

flang/test/Driver/override-triple.ll

+; Verify that the module triple is overridden by the driver - even in the presence
+; of a module triple.
+; NOTE: At the time of writing, the tested behaviour was consistent with Clang
+
+;-------------
+; RUN COMMANDS
+;-------------
+; RUN: %flang_fc1 -S %s -o - 2>&1 | FileCheck %s
+; RUN: %flang -S  %s -o - 2>&1 | FileCheck %s
+
+;----------------
+; EXPECTED OUTPUT
+;----------------
+; CHECK: warning: overriding the module target triple with {{.*}}
+
+;------
+; INPUT
+;------
+; For the triple to be overridden by the driver, it needs to be different to the host triple.
+; Use a random string to guarantee that.
+target triple = "invalid-triple"
+
+define void @foo() {
+  ret void
+}

flang/test/lit.cfg.py

 #
 # For now we require '&&' between commands, until they get globally killed and
 # the test runner updated.
 config.test_format = lit.formats.ShTest(not llvm_config.use_lit_shell)
 
 # suffixes: A list of file extensions to treat as test files.
 config.suffixes = ['.c', '.cpp', '.f', '.F', '.ff', '.FOR', '.for', '.f77', '.f90', '.F90',
                    '.ff90', '.f95', '.F95', '.ff95', '.fpp', '.FPP', '.cuf'
-                   '.CUF', '.f18', '.F18', '.fir', '.f03', '.F03', '.f08', '.F08']
+                   '.CUF', '.f18', '.F18', '.fir', '.f03', '.F03', '.f08',
+                   '.F08', '.ll']
 
 config.substitutions.append(('%PATH%', config.environment['PATH']))
 config.substitutions.append(('%llvmshlibdir', config.llvm_shlib_dir))
 config.substitutions.append(('%pluginext', config.llvm_plugin_ext))
 
 llvm_config.use_default_substitutions()
 
 # ask llvm-config about asserts