[Flang] Exit gracefully with a useful message when we fail to lookup a target

[mnadeem]

Summary

Without this patch were asserting with a generic message Failed to create Target, but we already have a detailed error message stored in the variable error after calling lookupTarget() but this error was not getting used/printed.

With this patch we will emit a message with more details instead of a stack dump with a generic message.

[mnadeem]

flang/lib/Frontend/FrontendActions.cpp

601

I tried

unsigned diagID = ci.getDiagnostics().getCustomDiagID(clang::
           DiagnosticsEngine::Fatal, "unable to create target: '%0'");

ci.getDiagnostics().Report(diagID) << error;

it prints the error but does not terminate flang-new invocation for some reason.

[awarzynski]

flang/lib/Frontend/FrontendActions.cpp

600–605

You will need to update the function signature accordingly. Also, please add a test.

[awarzynski]

We already have an error message, so print it as well.

I'm not sure I follow - can you elaborate? This patch is switching from an assertion to a diagnostic. The error message inside the assert will be printed regardless of whether a diagnostic is used or not.

[mnadeem]

In D146333#4204007, @awarzynski wrote:

We already have an error message, so print it as well.

I'm not sure I follow - can you elaborate? This patch is switching from an assertion to a diagnostic. The error message inside the assert will be printed regardless of whether a diagnostic is used or not.

Before we were failing the assert with just a fixed message: "Failed to create Target".
With this patch we will also print the error description stored in the string error and then abort.

[mnadeem]

• Use diagnostics (reused existing diag)
• Add a test

[awarzynski]

In D146333#4204216, @mnadeem wrote:

In D146333#4204007, @awarzynski wrote:

We already have an error message, so print it as well.

I'm not sure I follow - can you elaborate? This patch is switching from an assertion to a diagnostic. The error message inside the assert will be printed regardless of whether a diagnostic is used or not.

Before we were failing the assert with just a fixed message: "Failed to create Target".
With this patch we will also print the error description stored in the string error and then abort.

Thanks for clarifying!

[awarzynski]

LGTM, thanks for improving this!

flang/test/Driver/target-machine-error.f90

2

[nit] IMHO, it would be easier to understand the intended logic in this test when using some random string (e.g. some-invalid-triple) rather than deliberately misspelling a valid triple (e.g. aarch67-linux-gnu) .

[tschuett]

flang/lib/Frontend/FrontendActions.cpp

619–620

Do you need to add a check here as well?

[mnadeem]

flang/lib/Frontend/FrontendActions.cpp

619–620

I briefly looked at the target code and it seems to me that this will only fail if the target does not support codgen or has not registered the target machine constructor. I think this is always expected to succeed.

flang/include/flang/Frontend/FrontendActions.h

 /// least run the prescanning, parsing, semantic checks and lower the parse
 /// tree to an MLIR module.
 class CodeGenAction : public FrontendAction {
 
   void executeAction() override;
   /// Runs prescan, parsing, sema and lowers to MLIR.
   bool beginSourceFileAction() override;
   /// Sets up LLVM's TargetMachine.
-  void setUpTargetMachine();
+  bool setUpTargetMachine();
   /// Runs the optimization (aka middle-end) pipeline on the LLVM module
   /// associated with this action.
   void runOptimizationPipeline(llvm::raw_pwrite_stream &os);
 
 protected:
   CodeGenAction(BackendActionTy act) : action{act} {};
   /// @name MLIR
   /// {

flang/lib/Frontend/FrontendActions.cpp

if (this->getCurrentInput().getKind().getLanguage() == Language::MLIR) {
     if (!module || mlir::failed(module->verifyInvariants())) {
       unsigned diagID = ci.getDiagnostics().getCustomDiagID(
           clang::DiagnosticsEngine::Error, "Could not parse FIR");
       ci.getDiagnostics().Report(diagID);
       return false;
     }
 
     mlirModule = std::make_unique<mlir::ModuleOp>(module.release());
-    setUpTargetMachine();
+    if (!setUpTargetMachine())
+      return false;
     const llvm::DataLayout &dl = tm->createDataLayout();
     setMLIRDataLayout(*mlirModule, dl);
     return true;
   }
 
   // Otherwise, generate an MLIR module from the input Fortran source
   if (getCurrentInput().getKind().getLanguage() != Language::Fortran) {
     unsigned diagID = ci.getDiagnostics().getCustomDiagID(
bool CodeGenAction::beginSourceFileAction() {
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
 
   if (ci.getInvocation().getFrontendOpts().features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     mlir::omp::OpenMPDialect::setIsDevice(
         *mlirModule, ci.getInvocation().getLangOpts().OpenMPIsDevice);
   }
 
-  setUpTargetMachine();
+  if (!setUpTargetMachine())
+    return false;
   const llvm::DataLayout &dl = tm->createDataLayout();
   setMLIRDataLayout(*mlirModule, dl);
 
   // Create a parse tree and lower it to FIR
   Fortran::parser::Program &parseTree{*ci.getParsing().parseTree()};
   lb.lower(parseTree, ci.getInvocation().getSemanticsContext());
 
   // run the default passes.
if (opts.PICLevel > 0) {
     llvmModule->setPICLevel(static_cast<llvm::PICLevel::Level>(opts.PICLevel));
     if (opts.IsPIE)
       llvmModule->setPIELevel(
           static_cast<llvm::PIELevel::Level>(opts.PICLevel));
   }
 
 }
 
-void CodeGenAction::setUpTargetMachine() {
+bool CodeGenAction::setUpTargetMachine() {
   CompilerInstance &ci = this->getInstance();
 
   const TargetOptions &targetOpts = ci.getInvocation().getTargetOpts();
   const std::string &theTriple = targetOpts.triple;
 
   // Create `Target`
   std::string error;
   const llvm::Target *theTarget =
       llvm::TargetRegistry::lookupTarget(theTriple, error);
-  assert(theTarget && "Failed to create Target");
+  if (!theTarget) {
+    ci.getDiagnostics().Report(clang::diag::err_fe_unable_to_create_target)
+        << error;
+    return false;
+  }
 
   // Create `TargetMachine`
   const auto &CGOpts = ci.getInvocation().getCodeGenOpts();
   std::optional<llvm::CodeGenOpt::Level> OptLevelOrNone =
       llvm::CodeGenOpt::getLevel(CGOpts.OptimizationLevel);
   assert(OptLevelOrNone && "Invalid optimization level!");
   llvm::CodeGenOpt::Level OptLevel = *OptLevelOrNone;
   std::string featuresStr = llvm::join(targetOpts.featuresAsWritten.begin(),
                                        targetOpts.featuresAsWritten.end(), ",");
   tm.reset(theTarget->createTargetMachine(
       theTriple, /*CPU=*/targetOpts.cpu,
       /*Features=*/featuresStr, llvm::TargetOptions(),
       /*Reloc::Model=*/CGOpts.getRelocationModel(),
       /*CodeModel::Model=*/std::nullopt, OptLevel));
   assert(tm && "Failed to create TargetMachine");
+  return true;
 }
 
 static std::unique_ptr<llvm::raw_pwrite_stream>
 getOutputStream(CompilerInstance &ci, llvm::StringRef inFile,
                 BackendActionTy action) {
   switch (action) {
   case BackendActionTy::Backend_EmitAssembly:
     return ci.createDefaultOutputFile(
void CodeGenAction::executeAction() {
   // 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();
 
   // Set the triple based on the targetmachine (this comes compiler invocation
   // and the command-line target option if specified, or the default if not
   // given on the command-line).
-  setUpTargetMachine();
+  if (!setUpTargetMachine())
+    return;
   const std::string &theTriple = tm->getTargetTriple().str();
 
   if (llvmModule->getTargetTriple() != theTriple) {
     ci.getDiagnostics().Report(clang::diag::warn_fe_override_module)
         << theTriple;
   }
 
   // Always set the triple and data layout, to make sure they match and are set.

flang/test/Driver/target-machine-error.f90

+! RUN: not %flang  --target=some-invalid-triple -S  %s -o \
+! RUN:   /dev/null 2>&1 | FileCheck %s
+! RUN: not %flang_fc1 -triple some-invalid-triple -S %s -o \
+! RUN:   /dev/null 2>&1 | FileCheck %s
+
+! CHECK: error: unable to create target: 'No available targets are compatible with triple "some-invalid-triple"'