[flang][driver] Add support for -include flag in flang -fc1

[skatrak]

Summary

This patch adds support for the -include flag to include header files before
parsing the input. It should implement the same behavior as the flag with the
same name in clang.

[awarzynski]

In what cases would this flag be used in practice? I've scanned Clang and couldn't find any answers.

[clementval]

In D143493#4110230, @awarzynski wrote:

In what cases would this flag be used in practice? I've scanned Clang and couldn't find any answers.

+1

[skatrak]

In D143493#4110230, @awarzynski wrote:

In what cases would this flag be used in practice? I've scanned Clang and couldn't find any answers.

It is introduced to the arguments list in Clang::AddPreprocessingOptions in certain cases to add the OpenMP wrapper "__clang_openmp_device_functions.h" to the list of includes for device offload. It seemed likely that we would need to add a similar mechanism eventually to flang as well, although I suppose it could also be useful in other situations.

[awarzynski]

In D143493#4110272, @skatrak wrote:

It is introduced to the arguments list in Clang::AddPreprocessingOptions in certain cases to add the OpenMP wrapper "__clang_openmp_device_functions.h" to the list of includes for device offload.

This is a use case in Clang ;-)

It seemed likely that we would need to add a similar mechanism eventually to flang as well

Possibly, but it's not needed yet?

I would rather refrain from adding flags to Flang only because a similar flag exists in Clang. I suggest abandoning this until there's a clear need for this in Flang.

[skatrak]

In D143493#4110323, @awarzynski wrote:

In D143493#4110272, @skatrak wrote:

It is introduced to the arguments list in Clang::AddPreprocessingOptions in certain cases to add the OpenMP wrapper "__clang_openmp_device_functions.h" to the list of includes for device offload.

This is a use case in Clang ;-)

It seemed likely that we would need to add a similar mechanism eventually to flang as well

Possibly, but it's not needed yet?

I would rather refrain from adding flags to Flang only because a similar flag exists in Clang. I suggest abandoning this until there's a clear need for this in Flang.

Sure, sounds reasonable. I suppose this will most likely come together with the rest of changes needed for basic offload then. Thank you!

clang/include/clang/Driver/Options.td

def iframeworkwithsysroot : JoinedOrSeparate<["-"], "iframeworkwithsysroot">,
   HelpText<"Add directory to SYSTEM framework search path, "
            "absolute paths are relative to -isysroot">,
   MetaVarName<"<directory>">, Flags<[CC1Option]>;
 def imacros : JoinedOrSeparate<["-", "--"], "imacros">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Include macros from file before parsing">, MetaVarName<"<file>">,
   MarshallingInfoStringVector<PreprocessorOpts<"MacroIncludes">>;
 def image__base : Separate<["-"], "image_base">;
 def include_ : JoinedOrSeparate<["-", "--"], "include">, Group<clang_i_Group>, EnumName<"include">,
-    MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option]>;
+    MetaVarName<"<file>">, HelpText<"Include file before parsing">, Flags<[CC1Option, FC1Option]>;
 def include_pch : Separate<["-"], "include-pch">, Group<clang_i_Group>, Flags<[CC1Option]>,
   HelpText<"Include precompiled header file">, MetaVarName<"<file>">,
   MarshallingInfoString<PreprocessorOpts<"ImplicitPCHInclude">>;
 def relocatable_pch : Flag<["-", "--"], "relocatable-pch">, Flags<[CC1Option]>,
   HelpText<"Whether to build a relocatable precompiled header">,
   MarshallingInfoFlag<FrontendOpts<"RelocatablePCH">>;
 def verify_pch : Flag<["-"], "verify-pch">, Group<Action_Group>, Flags<[CC1Option]>,
   HelpText<"Load and verify that a pre-compiled header file is not stale">;

flang/include/flang/Frontend/PreprocessorOptions.h

struct PreprocessorOptions {
 
   // Search directories specified by the user with -I
   // TODO: When adding support for more options related to search paths,
   // consider collecting them in a separate aggregate. For now we keep it here
   // as there is no point creating a class for just one field.
   std::vector<std::string> searchDirectoriesFromDashI;
   // Search directories specified by the user with -fintrinsic-modules-path
   std::vector<std::string> searchDirectoriesFromIntrModPath;
+  // Includes specified by the user with -include
+  std::vector<std::string> includes;
 
   PPMacrosFlag macrosFlag = PPMacrosFlag::Unknown;
 
   // -P: Suppress #line directives in -E output
   bool noLineDirectives{false};
 
   // -fno-reformat: Emit cooked character stream as -E output
   bool noReformat{false};

flang/include/flang/Parser/parsing.h

struct Options {
   using Predefinition = std::pair<std::string, std::optional<std::string>>;
 
   bool isFixedForm{false};
   int fixedFormColumns{72};
   common::LanguageFeatureControl features;
   std::vector<std::string> searchDirectories;
   std::vector<std::string> intrinsicModuleDirectories;
   std::vector<Predefinition> predefinitions;
+  std::vector<std::string> includes;
   bool instrumentedParse{false};
   bool isModuleFile{false};
   bool needProvenanceRangeToCharBlockMappings{false};
   Fortran::parser::Encoding encoding{Fortran::parser::Encoding::UTF_8};
   bool prescanAndReformat{false}; // -E
   bool showColors{false};
 };
 

flang/lib/Frontend/CompilerInvocation.cpp

for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
     opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
 
   // Prepend the ordered list of -intrinsic-modules-path
   // to the default location to search.
   for (const auto *currentArg :
        args.filtered(clang::driver::options::OPT_fintrinsic_modules_path))
     opts.searchDirectoriesFromIntrModPath.emplace_back(currentArg->getValue());
 
+  // Add the ordered list of -include's
+  for (const auto *currentArg :
+       args.filtered(clang::driver::options::OPT_include))
+    opts.includes.emplace_back(currentArg->getValue());
+
   // -cpp/-nocpp
   if (const auto *currentArg = args.getLastArg(
           clang::driver::options::OPT_cpp, clang::driver::options::OPT_nocpp))
     opts.macrosFlag =
         (currentArg->getOption().matches(clang::driver::options::OPT_cpp))
             ? PPMacrosFlag::Include
             : PPMacrosFlag::Exclude;
 
fortranOptions.searchDirectories.insert(
       preprocessorOptions.searchDirectoriesFromDashI.end());
 
   // Add the ordered list of -intrinsic-modules-path
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromIntrModPath.begin(),
       preprocessorOptions.searchDirectoriesFromIntrModPath.end());
 
+  // Adding includes specified by -include
+  fortranOptions.includes.insert(fortranOptions.includes.end(),
+                                 preprocessorOptions.includes.begin(),
+                                 preprocessorOptions.includes.end());
+
   //  Add the default intrinsic module directory
   fortranOptions.intrinsicModuleDirectories.emplace_back(getIntrinsicDir());
 
   // Add the directory supplied through -J/-module-dir to the list of search
   // directories
   if (moduleDirJ != ".")
     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
 

flang/lib/Parser/parsing.cpp

prescanner.set_fixedForm(options.isFixedForm)
       .AddCompilerDirectiveSentinel("dir$");
   if (options.features.IsEnabled(LanguageFeature::OpenACC)) {
     prescanner.AddCompilerDirectiveSentinel("$acc");
   }
   if (options.features.IsEnabled(LanguageFeature::OpenMP)) {
     prescanner.AddCompilerDirectiveSentinel("$omp");
     prescanner.AddCompilerDirectiveSentinel("$"); // OMP conditional line
   }
+
+  // Prescan -include's
+  for (auto include : options.includes) {
+    const SourceFile *includeFile =
+        allSources.Open(include, fileError, "."s /*prepend to search path*/);
+
+    if (!fileError.str().empty()) {
+      ProvenanceRange range{allSources.AddCompilerInsertion(include)};
+      messages_.Say(range, "%s"_err_en_US, fileError.str());
+      return sourceFile;
+    }
+    CHECK(includeFile);
+
+    ProvenanceRange range{
+        allSources.AddIncludedFile(*includeFile, ProvenanceRange{})};
+    prescanner.Prescan(range);
+  }
+
   ProvenanceRange range{allSources.AddIncludedFile(
       *sourceFile, ProvenanceRange{}, options.isModuleFile)};
   prescanner.Prescan(range);
   if (currentCooked_->BufferedBytes() == 0 && !options.isModuleFile) {
     // Input is empty.  Append a newline so that any warning
     // message about nonstandard usage will have provenance.
     currentCooked_->Put('\n', range.start());
   }

flang/test/Driver/driver-help.f90

 ! HELP-FC1-NEXT: -fopenacc              Enable OpenACC
 ! HELP-FC1-NEXT: -fopenmp               Parse OpenMP pragmas and generate parallel code.
 ! HELP-FC1-NEXT: -fpass-plugin=<dsopath> Load pass plugin from a dynamic shared object file (only with new pass manager).
 ! HELP-FC1-NEXT: -freciprocal-math      Allow division operations to be reassociated
 ! HELP-FC1-NEXT: -fstack-arrays         Attempt to allocate array temporaries on the stack, no matter their size
 ! HELP-FC1-NEXT: -fsyntax-only          Run the preprocessor, parser and semantic analysis stages
 ! HELP-FC1-NEXT: -fxor-operator         Enable .XOR. as a synonym of .NEQV.
 ! HELP-FC1-NEXT: -help                  Display available options
+! HELP-FC1-NEXT: -include <file>        Include file before parsing
 ! 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: -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>

flang/test/Driver/include-file.f90

+! Ensure argument -include works as expected with an included header file.
+
+! RUN: %flang_fc1 -E -include "%S/Inputs/basic-header-one.h" %s  2>&1 | FileCheck %s --check-prefix=INCLUDED
+! RUN: not %flang_fc1 -E -include does-not-exist.h %s  2>&1 | FileCheck %s --check-prefix=MISSING
+
+! INCLUDED: program MainDirectoryOne
+! INCLUDED-NOT: program X
+
+! MISSING: error: Source file 'does-not-exist.h' was not found
+! MISSING-NOT: program
+
+program X
+end