[Flang] Add main-file-name flag to flang -fc1

[domada]

Summary

Flag main-file-name is used to store information about original input file. Information about original input file is used for:

1. Determining the name of offload function for omp target pragma
2. Providing information about original input Fortran file for *mlir files and *.bc files

[clementval]

You should be able to get this information from the source location in MLIR.

[domada]

In D151445#4372892, @clementval wrote:

You should be able to get this information from the source location in MLIR.

Hi, thank you for your quick feedback.

You are right, the source location is provided in MLIR. Unfortunately, when we compile the source code with -save-temps file, then we use preprocessed file as the input for MLIR and we have no information about original source file.

Please look at the output of the command:
flang-new -save-temps -v **test.f90**

Output:
flang-new -fc1 /*some fc1 options */ **-o test.i test.f90**
flang-new -fc1 /*some fc1 options */ **-o test.bc test.i**

If we generate the code for OpenMP, then we generate two different preprocessed files (one for host code, the second one for the device). Then we use these preprocessed files as the input for MLIR. Originally we use the name of preprocessed file as the input for generation of unique name of OpenMP kernel function (please look at the original code inside mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp ). In consequence we generate two different kernel names for host and the device module (host and the device code should operate on the same name of the kernel function). To fix that isssue I provide an information about the original source file (not the name of the input preprocessed file).

[domada]

Patch rebased.

Detailed discussion about the need of introduction of the new flag can be found on LLVM discourse

[domada]

Patch not needed. Preprocessor change: https://reviews.llvm.org/D153910 enables passing information about original source file.

clang/include/clang/Driver/Options.td

 
 def version : Flag<["-"], "version">,
   HelpText<"Print the compiler version">,
   Flags<[CC1Option, CC1AsOption, FC1Option, NoDriverOption]>,
   MarshallingInfoFlag<FrontendOpts<"ShowVersion">>;
 
 def main_file_name : Separate<["-"], "main-file-name">,
   HelpText<"Main file name to use for debug info and source if missing">,
-  Flags<[CC1Option, CC1AsOption, NoDriverOption]>,
+  Flags<[CC1Option, CC1AsOption, NoDriverOption, FC1Option]>,
   MarshallingInfoString<CodeGenOpts<"MainFileName">>;
 def split_dwarf_output : Separate<["-"], "split-dwarf-output">,
   HelpText<"File name to use for split dwarf debug info output">,
   Flags<[CC1Option, CC1AsOption, NoDriverOption]>,
   MarshallingInfoString<CodeGenOpts<"SplitDwarfOutput">>;
 
 let Flags = [CC1Option, FC1Option, NoDriverOption] in {
 

clang/lib/Driver/ToolChains/Flang.cpp

 //===-- Flang.cpp - Flang+LLVM ToolChain Implementations --------*- 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
 //
 //===----------------------------------------------------------------------===//
 
 
 #include "Flang.h"
 #include "CommonArgs.h"
 
 #include "clang/Driver/Options.h"
 #include "llvm/Frontend/Debug/Options.h"
+#include "llvm/Support/Path.h"
 
 #include <cassert>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
if (isa<PreprocessJobAction>(JA)) {
     }
   } else if (isa<AssembleJobAction>(JA)) {
     CmdArgs.push_back("-emit-obj");
   } else {
     assert(false && "Unexpected action class for Flang tool.");
   }
 
   const InputInfo &Input = Inputs[0];
+  if (Input.isFilename()) {
+    CmdArgs.push_back("-main-file-name");
+    CmdArgs.push_back(
+        Args.MakeArgString(llvm::sys::path::filename(Input.getBaseInput())));
+  }
   types::ID InputType = Input.getType();
 
   // Add preprocessing options like -I, -D, etc. if we are using the
   // preprocessor (i.e. skip when dealing with e.g. binary files).
   if (types::getPreprocessedType(InputType) != types::TY_INVALID)
     addPreprocessingOptions(Args, CmdArgs);
 
   addFortranDialectOptions(Args, CmdArgs);

flang/include/flang/Frontend/FrontendOptions.h

struct FrontendOptions {
   std::vector<std::string> mlirArgs;
 
   // Return the appropriate input kind for a file extension. For example,
   /// "*.f" would return Language::Fortran.
   ///
   /// \return The input kind for the extension, or Language::Unknown if the
   /// extension is not recognized.
   static InputKind getInputKindForExtension(llvm::StringRef extension);
+
+  std::string mainFileName;
 };
 } // namespace Fortran::frontend
 
 #endif // FORTRAN_FRONTEND_FRONTENDOPTIONS_H

flang/lib/Frontend/CompilerInvocation.cpp

bool CompilerInvocation::createFromArgs(
   success &= parseDialectArgs(res, args, diags);
   success &= parseDiagArgs(res, args, diags);
   res.frontendOpts.llvmArgs =
       args.getAllArgValues(clang::driver::options::OPT_mllvm);
 
   res.frontendOpts.mlirArgs =
       args.getAllArgValues(clang::driver::options::OPT_mmlir);
 
+  res.frontendOpts.mainFileName = std::string(
+      args.getLastArgValue(clang::driver::options::OPT_main_file_name));
+
   success &= parseFloatingPointArgs(res, args, diags);
 
   // Set the string to be used as the return value of the COMPILER_OPTIONS
   // intrinsic of iso_fortran_env. This is either passed in from the parent
   // compiler driver invocation with an environment variable, or failing that
   // set to the command line arguments of the frontend driver invocation.
   res.allCompilerInvocOpts = std::string();
   llvm::raw_string_ostream os(res.allCompilerInvocOpts);

flang/lib/Frontend/FrontendActions.cpp

lower::LoweringBridge lb = Fortran::lower::LoweringBridge::create(
       ci.getInvocation().getSemanticsContext().intrinsics(),
       ci.getInvocation().getSemanticsContext().targetCharacteristics(),
       ci.getParsing().allCooked(), ci.getInvocation().getTargetOpts().triple,
       kindMap, ci.getInvocation().getLoweringOpts(),
       ci.getInvocation().getFrontendOpts().envDefaults);
 
   // Fetch module from lb, so we can set
   mlirModule = std::make_unique<mlir::ModuleOp>(lb.getModule());
-
+  llvm::StringRef mainFileName =
+      ci.getInvocation().getFrontendOpts().mainFileName;
+  if (!mainFileName.empty())
+    mlirModule->setName(ci.getInvocation().getFrontendOpts().mainFileName);
   if (!setUpTargetMachine())
     return false;
 
   if (ci.getInvocation().getFrontendOpts().features.IsEnabled(
           Fortran::common::LanguageFeature::OpenMP)) {
     setOffloadModuleInterfaceAttributes(*mlirModule,
                                         ci.getInvocation().getLangOpts());
     setOffloadModuleInterfaceTargetAttribute(*mlirModule, tm->getTargetCPU(),

flang/test/Driver/driver-help.f90

 ! HELP-FC1-NEXT: -funderscoring         Appends one trailing underscore to external names
 ! HELP-FC1-NEXT: -fversion-loops-for-stride
 ! HELP-FC1-NEXT:                        Create unit-strided versions of loops
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -init-only             Only execute frontend initialization
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -load <dsopath>        Load the named plugin (dynamic shared object)
+! HELP-FC1-NEXT: -main-file-name <value> Main file name to use for debug info and source if missing
 ! HELP-FC1-NEXT: -menable-no-infs       Allow optimization to assume there are no infinities.
 ! HELP-FC1-NEXT: -menable-no-nans       Allow optimization to assume there are no NaNs.
 ! HELP-FC1-NEXT: -mllvm <value>         Additional arguments to forward to LLVM's option processing
 ! HELP-FC1-NEXT: -mmlir <value>         Additional arguments to forward to MLIR's option processing
 ! 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: -mreassociate          Allow reassociation transformations for floating-point instructions
 ! HELP-FC1-NEXT: -mrelocation-model <value>

flang/test/Driver/frontend-forwarding.f90

 ! RUN:     -fpass-plugin=Bye%pluginext \
 ! RUN:     -fversion-loops-for-stride \
 ! RUN:     -mllvm -print-before-all\
 ! RUN:     -mllvm -print-before-all \
 ! RUN:     -save-temps=obj \
 ! RUN:     -P \
 ! RUN:   | FileCheck %s
 
+! CHECK: "-main-file-name" "frontend-forwarding.f90"
 ! CHECK: "-P"
 ! CHECK: "-finput-charset=utf-8"
 ! CHECK: "-fdefault-double-8"
 ! CHECK: "-fdefault-integer-8"
 ! CHECK: "-fdefault-real-8"
 ! CHECK: "-flarge-sizes"
 ! CHECK: "-ffp-contract=fast"
 ! CHECK: "-menable-no-nans"

flang/test/Driver/mllvm.f90

 ! Test the `-mllvm` option
 
 ! 1. Test typical usage.
 ! RUN: %flang -S -mllvm -print-before-all %s -o - 2>&1 | FileCheck %s --check-prefix=OUTPUT
-! RUN: %flang_fc1 -S -mllvm -print-before-all %s -o - 2>&1 | FileCheck %s --check-prefix=OUTPUT
+! RUN: %flang_fc1 -S -mllvm -print-before-all -main-file-name mllvm.f90 %s -o - 2>&1 | FileCheck %s --check-prefix=OUTPUT
 
 ! 2. Test invalid usage (`-print-before` requires an argument)
 ! RUN: not %flang -S -mllvm -print-before %s -o - 2>&1 | FileCheck %s --check-prefix=INVALID_USAGE
 
 ! OUTPUT: *** IR Dump Before Pre-ISel Intrinsic Lowering (pre-isel-intrinsic-lowering) ***
-! OUTPUT-NEXT: ; ModuleID = 'FIRModule'
-! OUTPUT-NEXT: source_filename = "FIRModule"
+! OUTPUT-NEXT: ; ModuleID = 'mllvm.f90'
+! OUTPUT-NEXT: source_filename = "mllvm.f90"
 
 ! INVALID_USAGE: flang (LLVM option parsing): for the --print-before option: requires a value!
 
 end program

mlir/lib/Target/LLVMIR/Dialect/OpenMP/OpenMPToLLVMIRTranslation.cpp

ompBuilder->createGlobalFlag(
       "__omp_rtl_assume_no_nested_parallelism");
   ompBuilder->M.addModuleFlag(llvm::Module::Max, "openmp-device",
                               attribute.getOpenmpDeviceVersion());
   return success();
 }
 
 static bool getTargetEntryUniqueInfo(llvm::TargetRegionEntryInfo &targetInfo,
                                      omp::TargetOp targetOp,
-                                     llvm::StringRef parentName = "") {
+                                     llvm::StringRef parentName = "",
+                                     llvm::StringRef hostFileName = "") {
   auto fileLoc = targetOp.getLoc()->findInstanceOf<FileLineColLoc>();
-
   assert(fileLoc && "No file found from location");
-  StringRef fileName = fileLoc.getFilename().getValue();
+  StringRef fileName =
+      (!hostFileName.empty()) ? hostFileName : fileLoc.getFilename().getValue();
 
   llvm::sys::fs::UniqueID id;
   if (auto ec = llvm::sys::fs::getUniqueID(fileName, id)) {
     targetOp.emitError("Unable to get unique ID for file");
     return false;
   }
 
   uint64_t line = fileLoc.getLine();
auto bodyCB = [&](InsertPointTy allocaIP,
     llvm::BasicBlock *exitBlock = convertOmpOpRegions(
         targetRegion, "omp.target", builder, moduleTranslation, bodyGenStatus);
     builder.SetInsertPoint(exitBlock);
     return builder.saveIP();
   };
 
   llvm::OpenMPIRBuilder::LocationDescription ompLoc(builder);
   StringRef parentName = opInst.getParentOfType<LLVM::LLVMFuncOp>().getName();
+  StringRef fileName = "";
   llvm::TargetRegionEntryInfo entryInfo;
+  auto moduleOp = opInst.getParentOfType<mlir::ModuleOp>();
+  fileName = moduleOp.getName().value_or("");
 
-  if (!getTargetEntryUniqueInfo(entryInfo, targetOp, parentName))
+  if (!getTargetEntryUniqueInfo(entryInfo, targetOp, parentName, fileName))
     return failure();
 
   int32_t defaultValTeams = -1;
   int32_t defaultValThreads = -1;
 
   builder.restoreIP(moduleTranslation.getOpenMPBuilder()->createTarget(
       ompLoc, builder.saveIP(), entryInfo, defaultValTeams, defaultValThreads,
       inputs, bodyCB));