[flang][driver] Add forced form flags and -ffixed-line-length

[FarisRehman]

Summary

Add support for the following layout options:

• -ffree-form
• -ffixed-form
• -ffixed-line-length=n (alias -ffixed-line-length-n)

Additionally remove options -fno-free-form and -fno-fixed-form as they were initially added to forward to gfortran but gfortran does not support these flags.

This patch adds the flag FlangOnlyOption to the existing options -ffixed-form, -ffree-form and -ffree-line-length- in Options.td. As of commit 6a75496836ea14bcfd2f4b59d35a1cad4ac58cee, these flags are not currently forwarded to gfortran.

The default fixed line length in FrontendOptions is 72, based off the current default in Fortran::parser::Options. The line length cannot be set to a negative integer, or a positive integer less than 7 excluding 0, consistent with the behaviour of gfortran.

This patch does not add -ffree-line-length-n as Fortran::parser::Options does not have a variable for free form columns.
Whilst fixedFormColumns variable is used in f18 for -ffree-line-length-n, f18 only allows -ffree-line-length-none/-ffree-line-length-0 and not a user-specified value. fixedFormcolumns cannot be used in the new driver as it is ignored in the frontend when dealing with free form files.

Summary of changes:

• Remove -fno-fixed-form and -fno-free-form from Options.td
• Make -ffixed-form, -ffree-form and -ffree-line-length-n FlangOnlyOption in Options.td
• Create AddFortranDialectOptions method in Flang.cpp
• Create FortranForm enum in FrontendOptions.h
• Add fortranForm_ and fixedFormColumns_ to Fortran::frontend::FrontendOptions
• Update fixed-form-test.f so that it guarantees that it fails when forced as a free form file to better facilitate testing.

[awarzynski]

Thank you for working on this @FarisRehman ! I've left a few inline comments, but nothing major. Really nice to see this being added and working as expected!

clang/include/clang/Driver/Options.td

4131–4132

This is a fairly long help message. This is what gfortran prints:

gfortran --help=joined | grep 'ffixed-line-length'
  -ffixed-line-length-<n>     Use n as character line width in fixed mode

A long version could be added using DocBrief field.

4164–4165

We can't have help text for these, can we? Perhaps worth mentioning in the commit message that this needs fixing. We are likely to experience this with other options too.

clang/lib/Driver/ToolChains/Flang.cpp

30–31

IIUC, you are adding Fortran dialect rather then preprocessor options here. See also gfortran docs: https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html.

flang/include/flang/Frontend/FrontendOptions.h

77–87

[nit] Perhaps Source file layout above enum class FortranForm?

flang/lib/Frontend/CompilerInstance.cpp

151–159

Hm, unwanted TABs?

Also, please keep note of: https://reviews.llvm.org/D95464 (there should be no conflicts from what I can tell).

flang/lib/Frontend/CompilerInvocation.cpp

170–175

Could be simplified using the ternary operator:

opts.fortranForm_ = (currentArg->getOption().matches(clang::driver::options::OPT_ffixed_form) ? FortranForm::FixedForm : FortranForm::FreeForm;

To me this would be more concise, but semantically it's identical. So please decide!

(similar comment for the bit below)

186

Please, could you comment hard-coded args:

} else if (argValue.getAsInteger(/*Radix=*/10, columns)) {

See LLVM's coding style

318–322

Hm, wouldn't this work:

fortranOptions.isFixedForm = (frontendOptions.fortranForm_ == FortranForm::FixedForm) ? true : false;

flang/test/Flang-Driver/Inputs/fixed-line-length-test.f

4

FIXME

flang/test/Flang-Driver/fixed-free-flag.f90

9–10

Current RUN lines are quite complicated and there's a lot going on. It might be safer to simplify them. Perhaps this:

! RUN: not %flang-new -fsyntax-only -ffree-form %S/Inputs/fixed-form-test.f  2>&1 | FileCheck %s --check-prefix=ERROR
! RUN: not %flang-new -fsyntax-only -ffixed-form %S/Inputs/free-form-test.f90  2>&1 | FileCheck %s --check-prefix=ERROR

So:

• -ffree-form + fixed form file (extension and contents) --> Failure
• -fixed-form + free form file (extension and contents) --> Failure

This is way you indeed test that the driver is forced to assume particular layout?

flang/test/Flang-Driver/fixed-line-length.f90

28

Could this be a regex instead?

33

The value is know, right? I would added it here. Also, the actual diagnostics printed is longer, isn't it?

Would it be possible to test negative numbers?

39

Regex?

[FarisRehman]

Address review comment

Address the review comment by @awarzynski

Summary of changes:

• Shorten help text
• Add method AddFortranDialectOptions to Flang.cpp
• Change style of code to use quaternary operator
• Update regression tests

[FarisRehman]

flang/lib/Frontend/CompilerInstance.cpp

151–159

I believe this is just Phabricator showing the comments have been indented

[awarzynski]

@FarisRehman, thank you for addressing my comments! I've just realised that gfortran doesn't actually support -fno-fixed-form or -fno-free-form:

$ gfortran -ffixed-form -fno-fixed-form test.f
gfortran: error: unrecognized command line option ‘-fno-fixed-form’

I've checked the other spellings too. If that's the case then perhaps the definitions in Options.td should be updated to reflect that? And if we don't use BooleanFFlag for these options then it should be much easier to add a help text too.

[FarisRehman]

Remove -fno-fixed-form and -fno-free-form

Remove options -fno-fixed-form and -fno-free-form allowing for help messages to be added to -ffixed-form and -ffree-form.

[tskeith]

clang/include/clang/Driver/Options.td

4131–4132

Why isn't this -ffixed-line-length=<value> (i.e. with an equals sign, not a hyphen)? Isn't that how clang does options with values? It's fine to support the gfortran form as an alternative but I think the primary goal should be good consistent style for options.

[FarisRehman]

Address review comment

This revision addresses a review comment by @tskeith

Summary of changes:

• Add a new option, ffixed_line_length_EQ, that defines -ffixed-line-length=
• Make option ffixed_line_length_VALUE (-ffixed-line-length-) an alias of ffixed_line_length_EQ, to be consistent with gfortran
• Add flag FlangOnlyOption to ffixed-form, ffree-form and ffixed-line-length

[awarzynski]

Thank you for working on this @FarisRehman !

[protze.joachim]

Before this patch, clang would happily ignore a -ffree-form flag. With this patch, none of -Wno-error=unknown-argument, -Wno-unknown-argument , -Qunused-arguments help to avoid clang from exiting with

error: unknown argument: '-ffree-form'

Why can't clang ignore these flags as any other unknown flags?

As a background: in the build system I'm dealing with, I cannot avoid that fortran flags are passed to the linking command. As C++ and fortran is involved, I prefer using clang++ as the linking command and explicitly link the fortran runtime library (at the moment gfortran, but in the future probably the flang runtime library)

[awarzynski]

Hi @protze.joachim,

Thank you for your feedback. I'm sorry that this is causing issues in your set-up.

In D95460#2632844, @protze.joachim wrote:

Before this patch, clang would happily ignore a -ffree-form flag.

It's a bit more nuanced than this. Originally, -ffree-form (and other similar flags) were added to be forwarded to gfortran. This forwarding was effectively switched off ~6 months before this patch, please see this commit. As such, these flags stopped being used/needed by Clang. This patch makes Flang "re-claim" them.

With this patch, none of -Wno-error=unknown-argument, -Wno-unknown-argument , -Qunused-arguments help to avoid clang from exiting with

error: unknown argument: '-ffree-form'

Why can't clang ignore these flags as any other unknown flags?

IIUC, this is not something specific to the options refactored in this patch. For example:

# Test -foo
clang-cl -c -Wno-unknown-argument -foo  file.c
clang -c -Wno-unknown-argument -foo  file.c
clang-13: error: unknown argument: '-foo'
# Test -ffree-form
clang-cl -c -Wno-unknown-argument -ffree-form  file.c
clang -c -Wno-unknown-argument -ffree-form  file.c
clang-13: error: unknown argument: '-ffree-form'

Basically, -Wno-unknown-argument is only honored in clang-cl. Also, it applies to any option rather then just the options modified here.
I'm not particularly familiar with the semantics of the diagnostics options that you listed (-Wno-error=unknown-argument, -Wno-unknown-argument , -Qunused-arguments), but I get the impression that in general clang does not ignore options that it does not know about. I couldn't find any example that would demonstrate otherwise.

As a background: in the build system I'm dealing with, I cannot avoid that fortran flags are passed to the linking command. As C++ and fortran is involved, I prefer using clang++ as the linking command and explicitly link the fortran runtime library (at the moment gfortran, but in the future probably the flang runtime library)

It sounds like your build system relies on the gfortran support in Clang, but this support has been "bit rotting". I'm keen to help you resolve your problems, but finding a solution that will work for clang, flang and gfortran might require some effort. Would you be able to step-up as Clang's gfortran-mode maintainer? (no pressure, just brainstorming!)
Alternatively, do you need ToT clang for your build system?

Thank you,
-Andrzej

[protze.joachim]

Hi Andrzej,

thanks for the detailed insights. I think I really misunderstood, what the -W flags can do here. I also was not up-to-date regarding the state of the flang implementation.

I just found, that compiling Spec OMP 2012 with clang-12 worked fine with my configuration, but compiling with current HEAD failed. Bisecting brought me to this patch.
What my build configuration basically does is to use gfortran to compile Fortran source to object files. Then I use clang/clang++ to link all the object files, basically:

gfortran -c foo.f
clang --gcc-toolchain=$(dirname $(dirname $(which gcc))) -lgfortran foo.o

In the build configuration, I can set FPORTABILITY flags for specific apps, but these flags are unfortunately passed to both the compile and the link step. Setting FLD to clang used to work, and now it broke.

One of my reasons for linking with clang is to make sure, that as much LLVM libraries as possible are linked. Especially, I want to pick up the LLVM version of the ThreadSanitizer runtime.

I tried to change my build configuration to use flang. After fixing some of the code (removing save keyword from variables, when having a global save), I could successfully compile one of the codes. Since flang under the hood uses gfortran for linking, this configuration picks up the GNU version of the ThreadSanitizer runtime. The GNU runtime is typically built as a dynamic library and comes with ~30-40% performance penalty. So, even when compiling with flang, I would prefer to link using clang.

I have no idea about the compiler internals, but would it be possible to mark the flang flags as known to the compiler tool-chain, but not used in case of clang? Finally, this would result in a -Wunused-command-line-argument warning.

Best
Joachim

[awarzynski]

Thank you for you reply Joachim,

I see 3 options here:

OPTION 1: make Clang accept these options
This would be as simple as removing the FlangOnlyOption from the corresponding TableGen definitions in Options.td. However, since we added help texts to their definitions, these options would be displayed together with other options when using clang --help. Given that these options are _not supported_ by clang, I think that we should avoid this upstream. However, this could be a quick and easy fix for you downstream. More on clang -help in this RFC.

OPTION 2: tweak the driver
From your description, it seems like it would make more sense to tweak the driver so that it can work in .e.g _linker_ mode. In such a mode, it would skip the compilation phase and ignore the compilation flags altogether. IMHO this would be the most sound approach here, but it may require a bit of work. I would start by asking on cfe-dev - it's likely that more projects use clang as a linker driver. Perhaps it's already possible?

OPTION 3: tweak -Wno-unknown-argument
I would expect -Wno-unknown-argument to work here as you initially suggested. I'm not familiar with its semantics or e.g. DiagnosticDriverKinds.td (there's a lot in there!). But sometimes you can tweak these things with a one-line change and then stuff auto-magically works. I can take a look at some point next week. It might be a low hanging fruit or a dead end.

What are you thoughts?

Best,
Andrzej

[awarzynski]

Hi @protze.joachim ,

Interestingly, GCC does not _error_ when using gfortran flags:

$ gcc -ffree-form file.c
cc1: warning: command line option ‘-ffree-form’ is valid for Fortran but not for C

I've implemented similar behavior for Clang in https://reviews.llvm.org/D99353. Please, could you take a look and see whether that solves your problem?

-Andrzej

clang/include/clang/Driver/Options.td

 def cpp : Flag<["-"], "cpp">, Group<gfortran_Group>;
 def nocpp : Flag<["-"], "nocpp">, Group<gfortran_Group>;
 def static_libgfortran : Flag<["-"], "static-libgfortran">, Group<gfortran_Group>;
 
 // "f" options with values for gfortran.
 def fblas_matmul_limit_EQ : Joined<["-"], "fblas-matmul-limit=">, Group<gfortran_Group>;
 def fcheck_EQ : Joined<["-"], "fcheck=">, Group<gfortran_Group>;
 def fcoarray_EQ : Joined<["-"], "fcoarray=">, Group<gfortran_Group>;
 def fconvert_EQ : Joined<["-"], "fconvert=">, Group<gfortran_Group>;
-def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<gfortran_Group>;
 def ffpe_trap_EQ : Joined<["-"], "ffpe-trap=">, Group<gfortran_Group>;
 def ffree_line_length_VALUE : Joined<["-"], "ffree-line-length-">, Group<gfortran_Group>;
 def finit_character_EQ : Joined<["-"], "finit-character=">, Group<gfortran_Group>;
 def finit_integer_EQ : Joined<["-"], "finit-integer=">, Group<gfortran_Group>;
 def finit_logical_EQ : Joined<["-"], "finit-logical=">, Group<gfortran_Group>;
 def finit_real_EQ : Joined<["-"], "finit-real=">, Group<gfortran_Group>;
 def fmax_array_constructor_EQ : Joined<["-"], "fmax-array-constructor=">, Group<gfortran_Group>;
 def fmax_errors_EQ : Joined<["-"], "fmax-errors=">, Group<gfortran_Group>;
 def fmax_stack_var_size_EQ : Joined<["-"], "fmax-stack-var-size=">, Group<gfortran_Group>;

 defm default_double_8 : BooleanFFlag<"default-double-8">, Group<gfortran_Group>;
 defm default_integer_8 : BooleanFFlag<"default-integer-8">, Group<gfortran_Group>;
 defm default_real_8 : BooleanFFlag<"default-real-8">, Group<gfortran_Group>;
 defm dollar_ok : BooleanFFlag<"dollar-ok">, Group<gfortran_Group>;
 defm dump_fortran_optimized : BooleanFFlag<"dump-fortran-optimized">, Group<gfortran_Group>;
 defm dump_fortran_original : BooleanFFlag<"dump-fortran-original">, Group<gfortran_Group>;
 defm dump_parse_tree : BooleanFFlag<"dump-parse-tree">, Group<gfortran_Group>;
 defm external_blas : BooleanFFlag<"external-blas">, Group<gfortran_Group>;
 defm f2c : BooleanFFlag<"f2c">, Group<gfortran_Group>;
-defm fixed_form : BooleanFFlag<"fixed-form">, Group<gfortran_Group>;
-defm free_form : BooleanFFlag<"free-form">, Group<gfortran_Group>;
 defm frontend_optimize : BooleanFFlag<"frontend-optimize">, Group<gfortran_Group>;
 defm implicit_none : BooleanFFlag<"implicit-none">, Group<gfortran_Group>;
 defm init_local_zero : BooleanFFlag<"init-local-zero">, Group<gfortran_Group>;
 defm integer_4_integer_8 : BooleanFFlag<"integer-4-integer-8">, Group<gfortran_Group>;
 defm intrinsic_modules_path : BooleanFFlag<"intrinsic-modules-path">, Group<gfortran_Group>;
 defm max_identifier_length : BooleanFFlag<"max-identifier-length">, Group<gfortran_Group>;
 defm module_private : BooleanFFlag<"module-private">, Group<gfortran_Group>;
 defm pack_derived : BooleanFFlag<"pack-derived">, Group<gfortran_Group>;
 defm protect_parens : BooleanFFlag<"protect-parens">, Group<gfortran_Group>;
def sycl_std_EQ : Joined<["-"], "sycl-std=">, Group<sycl_Group>, Flags<[CC1Option, NoArgumentUnused, CoreOption]>,
   MarshallingInfoString<LangOpts<"SYCLVersion">, "SYCL_None">, ShouldParseIf<fsycl.KeyPath>, AutoNormalizeEnum;
 
 //===----------------------------------------------------------------------===//
 // FlangOption and FC1 Options
 //===----------------------------------------------------------------------===//
 def test_io : Flag<["-"], "test-io">, Flags<[HelpHidden, FlangOption, FC1Option, FlangOnlyOption]>, Group<Action_Group>,
   HelpText<"Run the InputOuputTest action. Use for development and testing only.">;
 
+let Flags = [FC1Option, FlangOption, FlangOnlyOption] in {
+
+def ffixed_form : Flag<["-"], "ffixed-form">, Group<f_Group>,
+  HelpText<"Process source files in fixed form">;
+def ffree_form : Flag<["-"], "ffree-form">, Group<f_Group>,
+  HelpText<"Process source files in free form">;
+def ffixed_line_length_EQ : Joined<["-"], "ffixed-line-length=">, Group<f_Group>,
+  HelpText<"Use <value> as character line width in fixed mode">,
+  DocBrief<[{Set column after which characters are ignored in typical fixed-form lines in the source
+file}]>;
+def ffixed_line_length_VALUE : Joined<["-"], "ffixed-line-length-">, Group<f_Group>, Alias<ffixed_line_length_EQ>;
+
+}
+
 //===----------------------------------------------------------------------===//
 // CC1 Options
 //===----------------------------------------------------------------------===//
 
 let Flags = [CC1Option, NoDriverOption] in {
 
 //===----------------------------------------------------------------------===//
 // Target Options

clang/lib/Driver/ToolChains/Flang.h

 namespace clang {
 namespace driver {
 
 namespace tools {
 
 /// Flang compiler tool.
 class LLVM_LIBRARY_VISIBILITY Flang : public Tool {
 private:
+  /// Extract fortran dialect options from the driver arguments and add them to
+  /// the list of arguments for the generated command/job.
+  ///
+  /// \param [in] Args The list of input driver arguments
+  /// \param [out] CmdArgs The list of output command arguments
+  void AddFortranDialectOptions(const llvm::opt::ArgList &Args,
+                                llvm::opt::ArgStringList &CmdArgs) const;
+
   /// Extract preprocessing options from the driver arguments and add them to
   /// the preprocessor command arguments.
   ///
   /// \param [in] Args The list of input driver arguments
   /// \param [out] CmdArgs The list of output command arguments
   void AddPreprocessingOptions(const llvm::opt::ArgList &Args,
                                llvm::opt::ArgStringList &CmdArgs) const;
 

clang/lib/Driver/ToolChains/Flang.cpp

 
 #include <cassert>
 
 using namespace clang::driver;
 using namespace clang::driver::tools;
 using namespace clang;
 using namespace llvm::opt;
 
+void Flang::AddFortranDialectOptions(const ArgList &Args,
+                                     ArgStringList &CmdArgs) const {
+  Args.AddAllArgs(CmdArgs, {options::OPT_ffixed_form, options::OPT_ffree_form,
+                            options::OPT_ffixed_line_length_EQ});
+}
+
 void Flang::AddPreprocessingOptions(const ArgList &Args,
                                     ArgStringList &CmdArgs) const {
   Args.AddAllArgs(CmdArgs, {options::OPT_D, options::OPT_U, options::OPT_I});
 }
 
 void Flang::ConstructJob(Compilation &C, const JobAction &JA,
                          const InputInfo &Output, const InputInfoList &Inputs,
                          const ArgList &Args, const char *LinkingOutput) const {
   const auto &TC = getToolChain();
   // TODO: Once code-generation is available, this will need to be commented
   // out.
   // const llvm::Triple &Triple = TC.getEffectiveTriple();
void Flang::ConstructJob(Compilation &C, const JobAction &JA,
   const InputInfo &Input = Inputs[0];
   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);
+
   if (Output.isFilename()) {
     CmdArgs.push_back("-o");
     CmdArgs.push_back(Output.getFilename());
   } else {
     assert(Output.isNothing() && "Invalid output.");
   }
 
   assert(Input.isFilename() && "Invalid input.");

flang/include/flang/Frontend/FrontendOptions.h

enum class Language : uint8_t {
   /// LLVM IR: we accept this so that we can run the optimizer on it,
   /// and compile it to assembly or object code.
   LLVM_IR,
 
   /// @{ Languages that the frontend can parse and compile.
   Fortran,
 };
 
+// Source file layout
+enum class FortranForm {
+  /// The user has not specified a form. Base the form off the file extension.
+  Unknown,
+
+  /// -ffree-form
+  FixedForm,
+
+  /// -ffixed-form
+  FreeForm
+};
+
 /// The kind of a file that we've been handed as an input.
 class InputKind {
 private:
   Language lang_;
 
 public:
   /// The input file format.
   enum Format { Source, ModuleMap, Precompiled };
public:
   std::vector<FrontendInputFile> inputs_;
 
   /// The output file, if any.
   std::string outputFile_;
 
   /// The frontend action to perform.
   frontend::ActionKind programAction_;
 
+  // The form to process files in, if specified.
+  FortranForm fortranForm_ = FortranForm::Unknown;
+
+  // The column after which characters are ignored in fixed form lines in the
+  // source file.
+  int fixedFormColumns_ = 72;
+
 public:
   FrontendOptions() : showHelp_(false), showVersion_(false) {}
 
   // 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);
 };
 } // namespace Fortran::frontend
 
 #endif // LLVM_FLANG_FRONTEND_FRONTENDOPTIONS_H

flang/lib/Frontend/CompilerInstance.cpp

bool CompilerInstance::ExecuteAction(FrontendAction &act) {
   // Set some sane defaults for the frontend.
   invoc.SetDefaultFortranOpts();
   // Update the fortran options based on user-based input.
   invoc.setFortranOpts();
 
   // Run the frontend action `act` for every input file.
   for (const FrontendInputFile &fif : frontendOpts().inputs_) {
     if (act.BeginSourceFile(*this, fif)) {
+      if (invoc.frontendOpts().fortranForm_ == FortranForm::Unknown) {
         // Switch between fixed and free form format based on the input file
         // extension. Ideally we should have all Fortran options set before
         // entering this loop (i.e. processing any input files). However, we
         // can't decide between fixed and free form based on the file extension
         // earlier than this.
         invoc.fortranOpts().isFixedForm = fif.IsFixedForm();
+      }
       if (llvm::Error err = act.Execute()) {
         consumeError(std::move(err));
       }
       act.EndSourceFile();
     }
   }
   return !diagnostics().getClient()->getNumErrors();
 }
 

flang/lib/Frontend/CompilerInvocation.cpp

if (ik.IsUnknown()) {
       if (ik.IsUnknown())
         ik = Language::Unknown;
       if (i == 0)
         dashX = ik;
     }
 
     opts.inputs_.emplace_back(std::move(inputs[i]), ik);
   }
+
+  // Set fortranForm_ based on options -ffree-form and -ffixed-form.
+  if (const auto *arg = args.getLastArg(clang::driver::options::OPT_ffixed_form,
+          clang::driver::options::OPT_ffree_form)) {
+    opts.fortranForm_ =
+        arg->getOption().matches(clang::driver::options::OPT_ffixed_form)
+        ? FortranForm::FixedForm
+        : FortranForm::FreeForm;
+  }
+
+  // Set fixedFormColumns_ based on -ffixed-line-length=<value>
+  if (const auto *arg =
+          args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) {
+    llvm::StringRef argValue = llvm::StringRef(arg->getValue());
+    std::int64_t columns = -1;
+    if (argValue == "none") {
+      columns = 0;
+    } else if (argValue.getAsInteger(/*Radix=*/10, columns)) {
+      columns = -1;
+    }
+    if (columns < 0) {
+      diags.Report(clang::diag::err_drv_invalid_value_with_suggestion)
+          << arg->getOption().getName() << arg->getValue()
+          << "value must be 'none' or a non-negative integer";
+    } else if (columns == 0) {
+      opts.fixedFormColumns_ = 1000000;
+    } else if (columns < 7) {
+      diags.Report(clang::diag::err_drv_invalid_value_with_suggestion)
+          << arg->getOption().getName() << arg->getValue()
+          << "value must be at least seven";
+    } else {
+      opts.fixedFormColumns_ = columns;
+    }
+  }
   return dashX;
 }
 
 /// Parses all preprocessor input arguments and populates the preprocessor
 /// options accordingly.
 ///
 /// \param [in] opts The preprocessor options instance
 /// \param [out] args The list of input arguments
void CompilerInvocation::SetDefaultFortranOpts() {
   fortranOptions.predefinitions.emplace_back(
       "__flang_minor__", FLANG_VERSION_MINOR_STRING);
   fortranOptions.predefinitions.emplace_back(
       "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
 }
 
 void CompilerInvocation::setFortranOpts() {
   auto &fortranOptions = fortranOpts();
+  const auto &frontendOptions = frontendOpts();
   const auto &preprocessorOptions = preprocessorOpts();
 
+  if (frontendOptions.fortranForm_ != FortranForm::Unknown) {
+    fortranOptions.isFixedForm =
+        frontendOptions.fortranForm_ == FortranForm::FixedForm;
+  }
+  fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_;
+
   collectMacroDefinitions(preprocessorOptions, fortranOptions);
 
   fortranOptions.searchDirectories.insert(
       fortranOptions.searchDirectories.end(),
       preprocessorOptions.searchDirectoriesFromDashI.begin(),
       preprocessorOptions.searchDirectoriesFromDashI.end());
 }

flang/test/Flang-Driver/Inputs/fixed-form-test.f

       program FixedForm
+c     end
       end

flang/test/Flang-Driver/Inputs/fixed-line-length-test.f

+! The length of the line below is exactly 73 characters
+      program aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa
+      end

flang/test/Flang-Driver/driver-help-hidden.f90

 ! CHECK:USAGE: flang-new
 ! CHECK-EMPTY:
 ! CHECK-NEXT:OPTIONS:
 ! CHECK-NEXT: -###      Print (but do not run) the commands to run for this compilation
 ! CHECK-NEXT: -c        Only run preprocess, compile, and assemble steps
 ! CHECK-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! CHECK-NEXT: -E        Only run the preprocessor
 ! CHECK-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! CHECK-NEXT: -ffixed-form           Process source files in fixed form
+! CHECK-NEXT: -ffixed-line-length=<value>
+! CHECK-NEXT: Use <value> as character line width in fixed mode
+! CHECK-NEXT: -ffree-form            Process source files in free form
 ! CHECK-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! CHECK-NEXT: -help     Display available options
 ! CHECK-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! CHECK-NEXT: -o <file> Write output to <file>
 ! CHECK-NEXT: -test-io  Run the InputOuputTest action. Use for development and testing only.
 ! CHECK-NEXT: -U <macro>             Undefine macro <macro>
 ! CHECK-NEXT: --version Print version information
 

flang/test/Flang-Driver/driver-help.f90

 ! HELP:USAGE: flang-new
 ! HELP-EMPTY:
 ! HELP-NEXT:OPTIONS:
 ! HELP-NEXT: -###                   Print (but do not run) the commands to run for this compilation
 ! HELP-NEXT: -c                     Only run preprocess, compile, and assemble steps
 ! HELP-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-NEXT: -E                     Only run the preprocessor
 ! HELP-NEXT: -fcolor-diagnostics    Enable colors in diagnostics
+! HELP-NEXT: -ffixed-form           Process source files in fixed form
+! HELP-NEXT: -ffixed-line-length=<value>
+! HELP-NEXT: Use <value> as character line width in fixed mode
+! HELP-NEXT: -ffree-form            Process source files in free form
 ! HELP-NEXT: -fno-color-diagnostics Disable colors in diagnostics
 ! HELP-NEXT: -help                  Display available options
 ! HELP-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-NEXT: -o <file>              Write output to <file>
 ! HELP-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-NEXT: --version              Print version information
 
 !-------------------------------------------------------------
 ! EXPECTED OUTPUT FOR FLANG FRONTEND DRIVER (flang-new -fc1)
 !-------------------------------------------------------------
 ! HELP-FC1:USAGE: flang-new
 ! HELP-FC1-EMPTY:
 ! HELP-FC1-NEXT:OPTIONS:
 ! HELP-FC1-NEXT: -D <macro>=<value>     Define <macro> to <value> (or 1 if <value> omitted)
 ! HELP-FC1-NEXT: -emit-obj Emit native object files
 ! HELP-FC1-NEXT: -E                     Only run the preprocessor
+! HELP-FC1-NEXT: -ffixed-form           Process source files in fixed form
+! HELP-FC1-NEXT: -ffixed-line-length=<value>
+! HELP-FC1-NEXT: Use <value> as character line width in fixed mode
+! HELP-FC1-NEXT: -ffree-form            Process source files in free form
 ! HELP-FC1-NEXT: -help                  Display available options
 ! HELP-FC1-NEXT: -I <dir>               Add directory to the end of the list of include search paths
 ! HELP-FC1-NEXT: -o <file>              Write output to <file>
 ! HELP-FC1-NEXT: -U <macro>             Undefine macro <macro>
 ! HELP-FC1-NEXT: --version              Print version information
 
 !---------------
 ! EXPECTED ERROR
 !---------------
 ! ERROR: error: unknown argument '-helps'; did you mean '-help'

flang/test/Flang-Driver/fixed-free-flag.f90

+! Ensure arguments -ffree-form and -ffixed-form work as expected.
+
+! REQUIRES: new-flang-driver
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! RUN: not %flang-new -fsyntax-only -ffree-form %S/Inputs/fixed-form-test.f  2>&1 | FileCheck %s --check-prefix=FREEFORM
+! RUN: %flang-new -fsyntax-only -ffixed-form %S/Inputs/free-form-test.f90 2>&1 | FileCheck %s --check-prefix=FIXEDFORM
+
+!----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!----------------------------------------
+! RUN: not %flang-new -fc1 -fsyntax-only -ffree-form %S/Inputs/fixed-form-test.f  2>&1 | FileCheck %s --check-prefix=FREEFORM
+! RUN: %flang-new -fc1 -fsyntax-only -ffixed-form %S/Inputs/free-form-test.f90 2>&1 | FileCheck %s --check-prefix=FIXEDFORM
+
+!------------------------------------
+! EXPECTED OUTPUT FOR FREE FORM MODE
+!------------------------------------
+! FREEFORM:error: Could not parse
+
+!-------------------------------------
+! EXPECTED OUTPUT FOR FIXED FORM MODE
+!-------------------------------------
+! FIXEDFORM:free-form-test.f90:1:1: Character in fixed-form label field must be a digit

flang/test/Flang-Driver/fixed-line-length.f90

+! Ensure argument -ffixed-line-length=n works as expected.
+
+! REQUIRES: new-flang-driver
+
+!--------------------------
+! FLANG DRIVER (flang-new)
+!--------------------------
+! RUN: %flang-new -E %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=DEFAULTLENGTH
+! RUN: not %flang-new -E -ffixed-line-length=-2 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=NEGATIVELENGTH
+! RUN: not %flang-new -E -ffixed-line-length=3 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=INVALIDLENGTH
+! RUN: %flang-new -E -ffixed-line-length=none %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=UNLIMITEDLENGTH
+! RUN: %flang-new -E -ffixed-line-length=0 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=UNLIMITEDLENGTH
+! RUN: %flang-new -E -ffixed-line-length=13 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=LENGTH13
+
+!----------------------------------------
+! FRONTEND FLANG DRIVER (flang-new -fc1)
+!----------------------------------------
+! RUN: %flang-new -fc1 -E %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=DEFAULTLENGTH
+! RUN: not %flang-new -fc1 -E -ffixed-line-length=-2 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=NEGATIVELENGTH
+! RUN: not %flang-new -fc1 -E -ffixed-line-length=3 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=INVALIDLENGTH
+! RUN: %flang-new -fc1 -E -ffixed-line-length=none %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=UNLIMITEDLENGTH
+! RUN: %flang-new -fc1 -E -ffixed-line-length=0 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=UNLIMITEDLENGTH
+! RUN: %flang-new -fc1 -E -ffixed-line-length=13 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=LENGTH13
+
+!-------------------------------------
+! COMMAND ALIAS -ffixed-line-length-n
+!-------------------------------------
+! RUN: %flang-new -E -ffixed-line-length-13 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=LENGTH13
+! RUN: %flang-new -fc1 -E -ffixed-line-length-13 %S/Inputs/fixed-line-length-test.f  2>&1 | FileCheck %s --check-prefix=LENGTH13
+
+!-------------------------------------
+! EXPECTED OUTPUT WITH DEFAULT LENGTH
+!-------------------------------------
+! The line should be trimmed to 72 characters when reading based on the default value of fixed line length.
+! DEFAULTLENGTH: program{{(a{58})}}
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITH A NEGATIVE LENGTH
+!-----------------------------------------
+! NEGATIVELENGTH: invalid value '-2' in 'ffixed-line-length=','value must be 'none' or a non-negative integer'
+
+!-----------------------------------------
+! EXPECTED OUTPUT WITH LENGTH LESS THAN 7
+!-----------------------------------------
+! INVALIDLENGTH: invalid value '3' in 'ffixed-line-length=','value must be at least seven'
+
+!---------------------------------------
+! EXPECTED OUTPUT WITH UNLIMITED LENGTH
+!---------------------------------------
+! The line should not be trimmed and so 73 characters (including spaces) should be read.
+! UNLIMITEDLENGTH: program{{(a{59})}}
+
+!--------------------------------
+! EXPECTED OUTPUT WITH LENGTH 13
+!--------------------------------
+! LENGTH13: program