[flang][driver] Define the default frontend driver triple

[awarzynski]

Summary

SUMMARY
Currently, the frontend driver assumes that a target triple is either:

• provided by the frontend itself (e.g. when lowering and generating code),
• specified through the -triple/-target command line flags.

If -triple/-target is not used, the frontend will simply use the host
triple.

This is going to be insufficient when e.g. consuming an LLVM IR file
that has no triple specified (note: reading LLVM files is WIP). We
shouldn't require the triple to be specified via the command line in
such situation. Instead, the frontend driver should contain a good
default, e.g. the host triple.

This patch updates Flang's CompilerInvocation to do just that, i.e.
defines its default target triple. Similarly to Clang:

• the default CompilerInvocation triple is set as the host triple,
• the value specified with -triple takes precedence over the frontend driver default and the current module triple,
• the frontend driver default takes precedence over the module triple.

TESTS
This change requires 2 unit tests to be updated. That's because relevant
frontend actions are updated to assume that there's always a valid
triple available in the current CompilerInvocation. This update is
required because the unit tests bypass the regular CompilerInvocation
set-up (in particular, they don't call
CompilerInvocation::CreateFromArgs). I've also taken the liberty to
disable the pre-precossor formatting in the affected unit tests as well
(it is not required).

No new tests are added. As flang-new -fc1 does not support consuming
LLVM IR files just yet, it is not possible to compile an LLVM IR file
without a triple. More specifically, atm all LLVM IR files are generated
and stored internally and the driver makes sure that these contain a
valid target triple. This is about to change in D124667 (which adds
support for reading LLVM IR/BC files) and that's where tests for
exercising the default frontend driver triple will be added.

WHAT DOES CLANG DO?
For reference, the default target triple for Clang's
CompilerInvocation is set through option marshalling infra [1] in
Options.td. Please check the definition of the -triple flag:

def triple : Separate<["-"], "triple">,
  HelpText<"Specify target triple (e.g. i686-apple-darwin9)">,
  MarshallingInfoString<TargetOpts<"Triple">, "llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple())">,
  AlwaysEmit, Normalizer<"normalizeTriple">;

Ideally, we should re-use the marshalling infra in Flang.

[1] https://clang.llvm.org/docs/InternalsManual.html#option-marshalling-infrastructure

[ekieri]

LGTM, just a small suggestion: Could you add a note about the missing tests (that (and why) they are in D124667) to the commit message?

flang/lib/Frontend/CompilerInvocation.cpp

567

or above? Call is below, definition above.

[awarzynski]

Update the comment in "CompilerInvocation.cpp"

[awarzynski]

In D124664#3484750, @ekieri wrote:

LGTM, just a small suggestion: Could you add a note about the missing tests (that (and why) they are in D124667) to the commit message?

Done, thanks for the suggestion!

Hopefully the commit message makes it clear. Ideally, I should've done a better job splitting this, D124665 and D124667 into testable units. It all started as one change :)

flang/lib/Frontend/CompilerInvocation.cpp

567

Thanks, I've clarified this.

[ekieri]

Looks good, thanks!

flang/lib/Frontend/CompilerInvocation.cpp

 #include "flang/Version.inc"
 #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/ADT/Triple.h"
 #include "llvm/Option/Arg.h"
 #include "llvm/Option/ArgList.h"
 #include "llvm/Option/OptTable.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/FileUtilities.h"
+#include "llvm/Support/Host.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Support/Process.h"
 #include "llvm/Support/raw_ostream.h"
 #include <memory>
 
 using namespace Fortran::frontend;
 
 //===----------------------------------------------------------------------===//

 }
 
 /// Parses all target input arguments and populates the target
 /// options accordingly.
 ///
 /// \param [in] opts The target options instance to update
 /// \param [in] args The list of input arguments (from the compiler invocation)
 static void ParseTargetArgs(TargetOptions &opts, llvm::opt::ArgList &args) {
-  opts.triple = args.getLastArgValue(clang::driver::options::OPT_triple);
+  if (const llvm::opt::Arg *a =
+          args.getLastArg(clang::driver::options::OPT_triple))
+    opts.triple = a->getValue();
 }
 
 // Tweak the frontend configuration based on the frontend action
 static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
   if (opts.programAction == DebugDumpParsingLog)
     opts.instrumentedParse = true;
 
   if (opts.programAction == DebugDumpProvenance ||

 }
 
 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
     llvm::ArrayRef<const char *> commandLineArgs,
     clang::DiagnosticsEngine &diags) {
 
   bool success = true;
 
+  // Set the default triple for this CompilerInvocation. This might be
+  // overridden by users with `-triple` (see the call to `ParseTargetArgs`
+  // below).
+  // NOTE: Like in Clang, it would be nice to use option marshalling
+  // for this so that the entire logic for setting-up the triple is in one
+  // place.
+  res.targetOpts().triple =
+      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
+
   // Parse the arguments
   const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable();
   const unsigned includedFlagsBitmask = clang::driver::options::FC1Option;
   unsigned missingArgIndex, missingArgCount;
   llvm::opt::InputArgList args = opts.ParseArgs(
       commandLineArgs, missingArgIndex, missingArgCount, includedFlagsBitmask);
 
   // Check for missing argument error.

flang/lib/Frontend/FrontendActions.cpp

 #include "flang/Parser/unparse.h"
 #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 "clang/Basic/DiagnosticFrontend.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Analysis/TargetTransformInfo.h"
 #include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/IR/LegacyPassManager.h"
 #include "llvm/MC/TargetRegistry.h"
 #include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/ErrorHandling.h"

 
 void EmitLLVMBitcodeAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   // 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 and configure `Target`
+  // Set the triple based on the CompilerInvocation set-up
+  const std::string &theTriple = ci.invocation().targetOpts().triple;
+  if (llvmModule->getTargetTriple() != theTriple) {
+    ci.diagnostics().Report(clang::diag::warn_fe_override_module) << theTriple;
+    llvmModule->setTargetTriple(theTriple);
+  }
+
+  // Create `Target`
   std::string error;
-  std::string theTriple = llvmModule->getTargetTriple();
   const llvm::Target *theTarget =
       llvm::TargetRegistry::lookupTarget(theTriple, error);
   assert(theTarget && "Failed to create Target");
 
   // Create and configure `TargetMachine`
   std::unique_ptr<llvm::TargetMachine> TM(
       theTarget->createTargetMachine(theTriple, /*CPU=*/"",
           /*Features=*/"", llvm::TargetOptions(), llvm::None));

 
 void BackendAction::ExecuteAction() {
   CompilerInstance &ci = this->instance();
   // 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 CompilerInvocation set-up
+  const std::string &theTriple = ci.invocation().targetOpts().triple;
+  if (llvmModule->getTargetTriple() != theTriple) {
+    ci.diagnostics().Report(clang::diag::warn_fe_override_module) << theTriple;
+    llvmModule->setTargetTriple(theTriple);
+  }
+
   // 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(
       theTarget->createTargetMachine(theTriple, /*CPU=*/"",
           /*Features=*/"", llvm::TargetOptions(), llvm::None));
   assert(TM && "Failed to create TargetMachine");
   llvmModule->setDataLayout(TM->createDataLayout());

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/ADT/Triple.h"
 #include "llvm/Support/FileSystem.h"
+#include "llvm/Support/Host.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) {
   // 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 = EmitLLVM;
-  compInst_.invocation().preprocessorOpts().noReformat = true;
+
+  // Set-up default target triple.
+  compInst_.invocation().targetOpts().triple =
+      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
 
   // Set-up the output stream. We are using output buffer wrapped as an output
   // stream, as opposed to an actual file (or a file descriptor).
   llvm::SmallVector<char> outputFileBuffer;
   std::unique_ptr<llvm::raw_pwrite_stream> outputFileStream(
       new llvm::raw_svector_ostream(outputFileBuffer));
   compInst_.set_outputStream(std::move(outputFileStream));
 

 
 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;
+
+  // Set-up default target triple.
+  compInst_.invocation().targetOpts().triple =
+      llvm::Triple::normalize(llvm::sys::getDefaultTargetTriple());
 
   // 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).