xref: /llvm-project/flang/lib/Frontend/CompilerInvocation.cpp (revision d18a9aeae9e6b7514186188ba71d1d9b6956fe16) 
1 //===- CompilerInvocation.cpp ---------------------------------------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "flang/Frontend/CompilerInvocation.h"
10 #include "flang/Common/Fortran-features.h"
11 #include "flang/Frontend/PreprocessorOptions.h"
12 #include "flang/Semantics/semantics.h"
13 #include "flang/Version.inc"
14 #include "clang/Basic/AllDiagnostics.h"
15 #include "clang/Basic/DiagnosticDriver.h"
16 #include "clang/Basic/DiagnosticOptions.h"
17 #include "clang/Driver/DriverDiagnostic.h"
18 #include "clang/Driver/Options.h"
19 #include "llvm/ADT/StringRef.h"
20 #include "llvm/ADT/StringSwitch.h"
21 #include "llvm/Option/Arg.h"
22 #include "llvm/Option/ArgList.h"
23 #include "llvm/Option/OptTable.h"
24 #include "llvm/Support/FileSystem.h"
25 #include "llvm/Support/FileUtilities.h"
26 #include "llvm/Support/Process.h"
27 #include "llvm/Support/raw_ostream.h"
28 #include <memory>
29 
30 using namespace Fortran::frontend;
31 
32 //===----------------------------------------------------------------------===//
33 // Initialization.
34 //===----------------------------------------------------------------------===//
35 CompilerInvocationBase::CompilerInvocationBase()
36     : diagnosticOpts_(new clang::DiagnosticOptions()),
37       preprocessorOpts_(new PreprocessorOptions()) {}
38 
39 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &x)
40     : diagnosticOpts_(new clang::DiagnosticOptions(x.GetDiagnosticOpts())),
41       preprocessorOpts_(new PreprocessorOptions(x.preprocessorOpts())) {}
42 
43 CompilerInvocationBase::~CompilerInvocationBase() = default;
44 
45 //===----------------------------------------------------------------------===//
46 // Deserialization (from args)
47 //===----------------------------------------------------------------------===//
48 static bool parseShowColorsArgs(
49     const llvm::opt::ArgList &args, bool defaultColor) {
50   // Color diagnostics default to auto ("on" if terminal supports) in the driver
51   // but default to off in cc1, needing an explicit OPT_fdiagnostics_color.
52   // Support both clang's -f[no-]color-diagnostics and gcc's
53   // -f[no-]diagnostics-colors[=never|always|auto].
54   enum {
55     Colors_On,
56     Colors_Off,
57     Colors_Auto
58   } ShowColors = defaultColor ? Colors_Auto : Colors_Off;
59 
60   for (auto *a : args) {
61     const llvm::opt::Option &O = a->getOption();
62     if (O.matches(clang::driver::options::OPT_fcolor_diagnostics) ||
63         O.matches(clang::driver::options::OPT_fdiagnostics_color)) {
64       ShowColors = Colors_On;
65     } else if (O.matches(clang::driver::options::OPT_fno_color_diagnostics) ||
66         O.matches(clang::driver::options::OPT_fno_diagnostics_color)) {
67       ShowColors = Colors_Off;
68     } else if (O.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) {
69       llvm::StringRef value(a->getValue());
70       if (value == "always")
71         ShowColors = Colors_On;
72       else if (value == "never")
73         ShowColors = Colors_Off;
74       else if (value == "auto")
75         ShowColors = Colors_Auto;
76     }
77   }
78 
79   return ShowColors == Colors_On ||
80       (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors());
81 }
82 
83 bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts,
84     llvm::opt::ArgList &args, bool defaultDiagColor) {
85   opts.ShowColors = parseShowColorsArgs(args, defaultDiagColor);
86 
87   return true;
88 }
89 
90 // Tweak the frontend configuration based on the frontend action
91 static void setUpFrontendBasedOnAction(FrontendOptions &opts) {
92   assert(opts.programAction != Fortran::frontend::InvalidAction &&
93       "Fortran frontend action not set!");
94 
95   if (opts.programAction == DebugDumpParsingLog)
96     opts.instrumentedParse = true;
97 
98   if (opts.programAction == DebugDumpProvenance ||
99       opts.programAction == Fortran::frontend::GetDefinition)
100     opts.needProvenanceRangeToCharBlockMappings = true;
101 }
102 
103 static bool ParseFrontendArgs(FrontendOptions &opts, llvm::opt::ArgList &args,
104     clang::DiagnosticsEngine &diags) {
105   unsigned numErrorsBefore = diags.getNumErrors();
106 
107   // By default the frontend driver creates a ParseSyntaxOnly action.
108   opts.programAction = ParseSyntaxOnly;
109 
110   // Treat multiple action options as an invocation error. Note that `clang
111   // -cc1` does accept multiple action options, but will only consider the
112   // rightmost one.
113   if (args.hasMultipleArgs(clang::driver::options::OPT_Action_Group)) {
114     const unsigned diagID = diags.getCustomDiagID(
115         clang::DiagnosticsEngine::Error, "Only one action option is allowed");
116     diags.Report(diagID);
117     return false;
118   }
119 
120   // Identify the action (i.e. opts.ProgramAction)
121   if (const llvm::opt::Arg *a =
122           args.getLastArg(clang::driver::options::OPT_Action_Group)) {
123     switch (a->getOption().getID()) {
124     default: {
125       llvm_unreachable("Invalid option in group!");
126     }
127     case clang::driver::options::OPT_test_io:
128       opts.programAction = InputOutputTest;
129       break;
130     case clang::driver::options::OPT_E:
131       opts.programAction = PrintPreprocessedInput;
132       break;
133     case clang::driver::options::OPT_fsyntax_only:
134       opts.programAction = ParseSyntaxOnly;
135       break;
136     case clang::driver::options::OPT_emit_obj:
137       opts.programAction = EmitObj;
138       break;
139     case clang::driver::options::OPT_fdebug_unparse:
140       opts.programAction = DebugUnparse;
141       break;
142     case clang::driver::options::OPT_fdebug_unparse_no_sema:
143       opts.programAction = DebugUnparseNoSema;
144       break;
145     case clang::driver::options::OPT_fdebug_unparse_with_symbols:
146       opts.programAction = DebugUnparseWithSymbols;
147       break;
148     case clang::driver::options::OPT_fdebug_dump_symbols:
149       opts.programAction = DebugDumpSymbols;
150       break;
151     case clang::driver::options::OPT_fdebug_dump_parse_tree:
152       opts.programAction = DebugDumpParseTree;
153       break;
154     case clang::driver::options::OPT_fdebug_dump_all:
155       opts.programAction = DebugDumpAll;
156       break;
157     case clang::driver::options::OPT_fdebug_dump_parse_tree_no_sema:
158       opts.programAction = DebugDumpParseTreeNoSema;
159       break;
160     case clang::driver::options::OPT_fdebug_dump_provenance:
161       opts.programAction = DebugDumpProvenance;
162       break;
163     case clang::driver::options::OPT_fdebug_dump_parsing_log:
164       opts.programAction = DebugDumpParsingLog;
165       break;
166     case clang::driver::options::OPT_fdebug_measure_parse_tree:
167       opts.programAction = DebugMeasureParseTree;
168       break;
169     case clang::driver::options::OPT_fdebug_pre_fir_tree:
170       opts.programAction = DebugPreFIRTree;
171       break;
172     case clang::driver::options::OPT_fget_symbols_sources:
173       opts.programAction = GetSymbolsSources;
174       break;
175     case clang::driver::options::OPT_fget_definition:
176       opts.programAction = GetDefinition;
177       break;
178     case clang::driver::options::OPT_init_only:
179       opts.programAction = InitOnly;
180       break;
181 
182       // TODO:
183       // case clang::driver::options::OPT_emit_llvm:
184       // case clang::driver::options::OPT_emit_llvm_only:
185       // case clang::driver::options::OPT_emit_codegen_only:
186       // case clang::driver::options::OPT_emit_module:
187       // (...)
188     }
189 
190     // Parse the values provided with `-fget-definition` (there should be 3
191     // integers)
192     if (llvm::opt::OptSpecifier(a->getOption().getID()) ==
193         clang::driver::options::OPT_fget_definition) {
194       unsigned optVals[3] = {0, 0, 0};
195 
196       for (unsigned i = 0; i < 3; i++) {
197         llvm::StringRef val = a->getValue(i);
198 
199         if (val.getAsInteger(10, optVals[i])) {
200           // A non-integer was encountered - that's an error.
201           diags.Report(clang::diag::err_drv_invalid_value)
202               << a->getOption().getName() << val;
203           break;
204         }
205       }
206       opts.getDefVals.line = optVals[0];
207       opts.getDefVals.startColumn = optVals[1];
208       opts.getDefVals.endColumn = optVals[2];
209     }
210   }
211 
212   // Parsing -load <dsopath> option and storing shared object path
213   if (llvm::opt::Arg *a = args.getLastArg(clang::driver::options::OPT_load)) {
214     opts.plugins.push_back(a->getValue());
215   }
216 
217   // Parsing -plugin <name> option and storing plugin name and setting action
218   if (const llvm::opt::Arg *a =
219           args.getLastArg(clang::driver::options::OPT_plugin)) {
220     opts.programAction = PluginAction;
221     opts.ActionName = a->getValue();
222   }
223 
224   opts.outputFile = args.getLastArgValue(clang::driver::options::OPT_o);
225   opts.showHelp = args.hasArg(clang::driver::options::OPT_help);
226   opts.showVersion = args.hasArg(clang::driver::options::OPT_version);
227 
228   // Get the input kind (from the value passed via `-x`)
229   InputKind dashX(Language::Unknown);
230   if (const llvm::opt::Arg *a =
231           args.getLastArg(clang::driver::options::OPT_x)) {
232     llvm::StringRef XValue = a->getValue();
233     // Principal languages.
234     dashX = llvm::StringSwitch<InputKind>(XValue)
235                 .Case("f90", Language::Fortran)
236                 .Default(Language::Unknown);
237 
238     // Some special cases cannot be combined with suffixes.
239     if (dashX.IsUnknown())
240       dashX = llvm::StringSwitch<InputKind>(XValue)
241                   .Case("ir", Language::LLVM_IR)
242                   .Default(Language::Unknown);
243 
244     if (dashX.IsUnknown())
245       diags.Report(clang::diag::err_drv_invalid_value)
246           << a->getAsString(args) << a->getValue();
247   }
248 
249   // Collect the input files and save them in our instance of FrontendOptions.
250   std::vector<std::string> inputs =
251       args.getAllArgValues(clang::driver::options::OPT_INPUT);
252   opts.inputs.clear();
253   if (inputs.empty())
254     // '-' is the default input if none is given.
255     inputs.push_back("-");
256   for (unsigned i = 0, e = inputs.size(); i != e; ++i) {
257     InputKind ik = dashX;
258     if (ik.IsUnknown()) {
259       ik = FrontendOptions::GetInputKindForExtension(
260           llvm::StringRef(inputs[i]).rsplit('.').second);
261       if (ik.IsUnknown())
262         ik = Language::Unknown;
263       if (i == 0)
264         dashX = ik;
265     }
266 
267     opts.inputs.emplace_back(std::move(inputs[i]), ik);
268   }
269 
270   // Set fortranForm based on options -ffree-form and -ffixed-form.
271   if (const auto *arg = args.getLastArg(clang::driver::options::OPT_ffixed_form,
272           clang::driver::options::OPT_ffree_form)) {
273     opts.fortranForm =
274         arg->getOption().matches(clang::driver::options::OPT_ffixed_form)
275         ? FortranForm::FixedForm
276         : FortranForm::FreeForm;
277   }
278 
279   // Set fixedFormColumns based on -ffixed-line-length=<value>
280   if (const auto *arg =
281           args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) {
282     llvm::StringRef argValue = llvm::StringRef(arg->getValue());
283     std::int64_t columns = -1;
284     if (argValue == "none") {
285       columns = 0;
286     } else if (argValue.getAsInteger(/*Radix=*/10, columns)) {
287       columns = -1;
288     }
289     if (columns < 0) {
290       diags.Report(clang::diag::err_drv_negative_columns)
291           << arg->getOption().getName() << arg->getValue();
292     } else if (columns == 0) {
293       opts.fixedFormColumns = 1000000;
294     } else if (columns < 7) {
295       diags.Report(clang::diag::err_drv_small_columns)
296           << arg->getOption().getName() << arg->getValue() << "7";
297     } else {
298       opts.fixedFormColumns = columns;
299     }
300   }
301 
302   // -f{no-}implicit-none
303   opts.features.Enable(
304       Fortran::common::LanguageFeature::ImplicitNoneTypeAlways,
305       args.hasFlag(clang::driver::options::OPT_fimplicit_none,
306           clang::driver::options::OPT_fno_implicit_none, false));
307 
308   // -f{no-}backslash
309   opts.features.Enable(Fortran::common::LanguageFeature::BackslashEscapes,
310       args.hasFlag(clang::driver::options::OPT_fbackslash,
311           clang::driver::options::OPT_fno_backslash, false));
312 
313   // -f{no-}logical-abbreviations
314   opts.features.Enable(Fortran::common::LanguageFeature::LogicalAbbreviations,
315       args.hasFlag(clang::driver::options::OPT_flogical_abbreviations,
316           clang::driver::options::OPT_fno_logical_abbreviations, false));
317 
318   // -f{no-}xor-operator
319   opts.features.Enable(Fortran::common::LanguageFeature::XOROperator,
320       args.hasFlag(clang::driver::options::OPT_fxor_operator,
321           clang::driver::options::OPT_fno_xor_operator, false));
322 
323   // -fno-automatic
324   if (args.hasArg(clang::driver::options::OPT_fno_automatic)) {
325     opts.features.Enable(Fortran::common::LanguageFeature::DefaultSave);
326   }
327 
328   if (args.hasArg(
329           clang::driver::options::OPT_falternative_parameter_statement)) {
330     opts.features.Enable(Fortran::common::LanguageFeature::OldStyleParameter);
331   }
332   if (const llvm::opt::Arg *arg =
333           args.getLastArg(clang::driver::options::OPT_finput_charset_EQ)) {
334     llvm::StringRef argValue = arg->getValue();
335     if (argValue == "utf-8") {
336       opts.encoding = Fortran::parser::Encoding::UTF_8;
337     } else if (argValue == "latin-1") {
338       opts.encoding = Fortran::parser::Encoding::LATIN_1;
339     } else {
340       diags.Report(clang::diag::err_drv_invalid_value)
341           << arg->getAsString(args) << argValue;
342     }
343   }
344 
345   setUpFrontendBasedOnAction(opts);
346   opts.dashX = dashX;
347 
348   return diags.getNumErrors() == numErrorsBefore;
349 }
350 
351 // Generate the path to look for intrinsic modules
352 static std::string getIntrinsicDir() {
353   // TODO: Find a system independent API
354   llvm::SmallString<128> driverPath;
355   driverPath.assign(llvm::sys::fs::getMainExecutable(nullptr, nullptr));
356   llvm::sys::path::remove_filename(driverPath);
357   driverPath.append("/../include/flang/");
358   return std::string(driverPath);
359 }
360 
361 /// Parses all preprocessor input arguments and populates the preprocessor
362 /// options accordingly.
363 ///
364 /// \param [in] opts The preprocessor options instance
365 /// \param [out] args The list of input arguments
366 static void parsePreprocessorArgs(
367     Fortran::frontend::PreprocessorOptions &opts, llvm::opt::ArgList &args) {
368   // Add macros from the command line.
369   for (const auto *currentArg : args.filtered(
370            clang::driver::options::OPT_D, clang::driver::options::OPT_U)) {
371     if (currentArg->getOption().matches(clang::driver::options::OPT_D)) {
372       opts.addMacroDef(currentArg->getValue());
373     } else {
374       opts.addMacroUndef(currentArg->getValue());
375     }
376   }
377 
378   // Add the ordered list of -I's.
379   for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I))
380     opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue());
381 
382   // Prepend the ordered list of -intrinsic-modules-path
383   // to the default location to search.
384   for (const auto *currentArg :
385       args.filtered(clang::driver::options::OPT_fintrinsic_modules_path))
386     opts.searchDirectoriesFromIntrModPath.emplace_back(currentArg->getValue());
387 
388   // -cpp/-nocpp
389   if (const auto *currentArg = args.getLastArg(
390           clang::driver::options::OPT_cpp, clang::driver::options::OPT_nocpp))
391     opts.macrosFlag =
392         (currentArg->getOption().matches(clang::driver::options::OPT_cpp))
393         ? PPMacrosFlag::Include
394         : PPMacrosFlag::Exclude;
395 
396   opts.noReformat = args.hasArg(clang::driver::options::OPT_fno_reformat);
397   opts.noLineDirectives = args.hasArg(clang::driver::options::OPT_P);
398 }
399 
400 /// Parses all semantic related arguments and populates the variables
401 /// options accordingly. Returns false if new errors are generated.
402 static bool parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
403     clang::DiagnosticsEngine &diags) {
404   unsigned numErrorsBefore = diags.getNumErrors();
405 
406   // -J/module-dir option
407   auto moduleDirList =
408       args.getAllArgValues(clang::driver::options::OPT_module_dir);
409   // User can only specify -J/-module-dir once
410   // https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html
411   if (moduleDirList.size() > 1) {
412     const unsigned diagID =
413         diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
414             "Only one '-module-dir/-J' option allowed");
415     diags.Report(diagID);
416   }
417   if (moduleDirList.size() == 1)
418     res.SetModuleDir(moduleDirList[0]);
419 
420   // -fdebug-module-writer option
421   if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) {
422     res.SetDebugModuleDir(true);
423   }
424 
425   // -module-suffix
426   if (const auto *moduleSuffix =
427           args.getLastArg(clang::driver::options::OPT_module_suffix)) {
428     res.SetModuleFileSuffix(moduleSuffix->getValue());
429   }
430 
431   // -f{no-}analyzed-objects-for-unparse
432   res.SetUseAnalyzedObjectsForUnparse(
433       args.hasFlag(clang::driver::options::OPT_fanalyzed_objects_for_unparse,
434           clang::driver::options::OPT_fno_analyzed_objects_for_unparse, true));
435 
436   return diags.getNumErrors() == numErrorsBefore;
437 }
438 
439 /// Parses all diagnostics related arguments and populates the variables
440 /// options accordingly. Returns false if new errors are generated.
441 static bool parseDiagArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
442     clang::DiagnosticsEngine &diags) {
443   unsigned numErrorsBefore = diags.getNumErrors();
444 
445   // -Werror option
446   // TODO: Currently throws a Diagnostic for anything other than -W<error>,
447   // this has to change when other -W<opt>'s are supported.
448   if (args.hasArg(clang::driver::options::OPT_W_Joined)) {
449     if (args.getLastArgValue(clang::driver::options::OPT_W_Joined)
450             .equals("error")) {
451       res.SetWarnAsErr(true);
452     } else {
453       const unsigned diagID =
454           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
455               "Only `-Werror` is supported currently.");
456       diags.Report(diagID);
457     }
458   }
459 
460   return diags.getNumErrors() == numErrorsBefore;
461 }
462 
463 /// Parses all Dialect related arguments and populates the variables
464 /// options accordingly. Returns false if new errors are generated.
465 static bool parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args,
466     clang::DiagnosticsEngine &diags) {
467   unsigned numErrorsBefore = diags.getNumErrors();
468 
469   // -fdefault* family
470   if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
471     res.defaultKinds().set_defaultRealKind(8);
472     res.defaultKinds().set_doublePrecisionKind(16);
473   }
474   if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) {
475     res.defaultKinds().set_defaultIntegerKind(8);
476     res.defaultKinds().set_subscriptIntegerKind(8);
477     res.defaultKinds().set_sizeIntegerKind(8);
478   }
479   if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) {
480     if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) {
481       // -fdefault-double-8 has to be used with -fdefault-real-8
482       // to be compatible with gfortran
483       const unsigned diagID =
484           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
485               "Use of `-fdefault-double-8` requires `-fdefault-real-8`");
486       diags.Report(diagID);
487     }
488     // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html
489     res.defaultKinds().set_doublePrecisionKind(8);
490   }
491   if (args.hasArg(clang::driver::options::OPT_flarge_sizes))
492     res.defaultKinds().set_sizeIntegerKind(8);
493 
494   // -fopenmp and -fopenacc
495   if (args.hasArg(clang::driver::options::OPT_fopenacc)) {
496     res.frontendOpts().features.Enable(
497         Fortran::common::LanguageFeature::OpenACC);
498   }
499   if (args.hasArg(clang::driver::options::OPT_fopenmp)) {
500     res.frontendOpts().features.Enable(
501         Fortran::common::LanguageFeature::OpenMP);
502   }
503 
504   // -pedantic
505   if (args.hasArg(clang::driver::options::OPT_pedantic)) {
506     res.set_EnableConformanceChecks();
507   }
508   // -std=f2018 (currently this implies -pedantic)
509   // TODO: Set proper options when more fortran standards
510   // are supported.
511   if (args.hasArg(clang::driver::options::OPT_std_EQ)) {
512     auto standard = args.getLastArgValue(clang::driver::options::OPT_std_EQ);
513     // We only allow f2018 as the given standard
514     if (standard.equals("f2018")) {
515       res.set_EnableConformanceChecks();
516     } else {
517       const unsigned diagID =
518           diags.getCustomDiagID(clang::DiagnosticsEngine::Error,
519               "Only -std=f2018 is allowed currently.");
520       diags.Report(diagID);
521     }
522   }
523   return diags.getNumErrors() == numErrorsBefore;
524 }
525 
526 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res,
527     llvm::ArrayRef<const char *> commandLineArgs,
528     clang::DiagnosticsEngine &diags) {
529 
530   bool success = true;
531 
532   // Parse the arguments
533   const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable();
534   const unsigned includedFlagsBitmask = clang::driver::options::FC1Option;
535   unsigned missingArgIndex, missingArgCount;
536   llvm::opt::InputArgList args = opts.ParseArgs(
537       commandLineArgs, missingArgIndex, missingArgCount, includedFlagsBitmask);
538 
539   // Check for missing argument error.
540   if (missingArgCount) {
541     diags.Report(clang::diag::err_drv_missing_argument)
542         << args.getArgString(missingArgIndex) << missingArgCount;
543     success = false;
544   }
545 
546   // Issue errors on unknown arguments
547   for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) {
548     auto argString = a->getAsString(args);
549     std::string nearest;
550     if (opts.findNearest(argString, nearest, includedFlagsBitmask) > 1)
551       diags.Report(clang::diag::err_drv_unknown_argument) << argString;
552     else
553       diags.Report(clang::diag::err_drv_unknown_argument_with_suggestion)
554           << argString << nearest;
555     success = false;
556   }
557 
558   success &= ParseFrontendArgs(res.frontendOpts(), args, diags);
559   parsePreprocessorArgs(res.preprocessorOpts(), args);
560   success &= parseSemaArgs(res, args, diags);
561   success &= parseDialectArgs(res, args, diags);
562   success &= parseDiagArgs(res, args, diags);
563 
564   return success;
565 }
566 
567 void CompilerInvocation::collectMacroDefinitions() {
568   auto &ppOpts = this->preprocessorOpts();
569 
570   for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) {
571     llvm::StringRef macro = ppOpts.macros[i].first;
572     bool isUndef = ppOpts.macros[i].second;
573 
574     std::pair<llvm::StringRef, llvm::StringRef> macroPair = macro.split('=');
575     llvm::StringRef macroName = macroPair.first;
576     llvm::StringRef macroBody = macroPair.second;
577 
578     // For an #undef'd macro, we only care about the name.
579     if (isUndef) {
580       parserOpts_.predefinitions.emplace_back(
581           macroName.str(), std::optional<std::string>{});
582       continue;
583     }
584 
585     // For a #define'd macro, figure out the actual definition.
586     if (macroName.size() == macro.size())
587       macroBody = "1";
588     else {
589       // Note: GCC drops anything following an end-of-line character.
590       llvm::StringRef::size_type End = macroBody.find_first_of("\n\r");
591       macroBody = macroBody.substr(0, End);
592     }
593     parserOpts_.predefinitions.emplace_back(
594         macroName, std::optional<std::string>(macroBody.str()));
595   }
596 }
597 
598 void CompilerInvocation::SetDefaultFortranOpts() {
599   auto &fortranOptions = fortranOpts();
600 
601   std::vector<std::string> searchDirectories{"."s};
602   fortranOptions.searchDirectories = searchDirectories;
603   fortranOptions.isFixedForm = false;
604 }
605 
606 // TODO: When expanding this method, consider creating a dedicated API for
607 // this. Also at some point we will need to differentiate between different
608 // targets and add dedicated predefines for each.
609 void CompilerInvocation::setDefaultPredefinitions() {
610   auto &fortranOptions = fortranOpts();
611   const auto &frontendOptions = frontendOpts();
612 
613   // Populate the macro list with version numbers and other predefinitions.
614   fortranOptions.predefinitions.emplace_back("__flang__", "1");
615   fortranOptions.predefinitions.emplace_back(
616       "__flang_major__", FLANG_VERSION_MAJOR_STRING);
617   fortranOptions.predefinitions.emplace_back(
618       "__flang_minor__", FLANG_VERSION_MINOR_STRING);
619   fortranOptions.predefinitions.emplace_back(
620       "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING);
621 
622   // Add predefinitions based on extensions enabled
623   if (frontendOptions.features.IsEnabled(
624           Fortran::common::LanguageFeature::OpenACC)) {
625     fortranOptions.predefinitions.emplace_back("_OPENACC", "202011");
626   }
627   if (frontendOptions.features.IsEnabled(
628           Fortran::common::LanguageFeature::OpenMP)) {
629     fortranOptions.predefinitions.emplace_back("_OPENMP", "201511");
630   }
631 }
632 
633 void CompilerInvocation::setFortranOpts() {
634   auto &fortranOptions = fortranOpts();
635   const auto &frontendOptions = frontendOpts();
636   const auto &preprocessorOptions = preprocessorOpts();
637   auto &moduleDirJ = moduleDir();
638 
639   if (frontendOptions.fortranForm != FortranForm::Unknown) {
640     fortranOptions.isFixedForm =
641         frontendOptions.fortranForm == FortranForm::FixedForm;
642   }
643   fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns;
644 
645   fortranOptions.features = frontendOptions.features;
646   fortranOptions.encoding = frontendOptions.encoding;
647 
648   // Adding search directories specified by -I
649   fortranOptions.searchDirectories.insert(
650       fortranOptions.searchDirectories.end(),
651       preprocessorOptions.searchDirectoriesFromDashI.begin(),
652       preprocessorOptions.searchDirectoriesFromDashI.end());
653 
654   // Add the ordered list of -intrinsic-modules-path
655   fortranOptions.searchDirectories.insert(
656       fortranOptions.searchDirectories.end(),
657       preprocessorOptions.searchDirectoriesFromIntrModPath.begin(),
658       preprocessorOptions.searchDirectoriesFromIntrModPath.end());
659 
660   //  Add the default intrinsic module directory at the end
661   fortranOptions.searchDirectories.emplace_back(getIntrinsicDir());
662 
663   // Add the directory supplied through -J/-module-dir to the list of search
664   // directories
665   if (moduleDirJ.compare(".") != 0)
666     fortranOptions.searchDirectories.emplace_back(moduleDirJ);
667 
668   if (frontendOptions.instrumentedParse)
669     fortranOptions.instrumentedParse = true;
670 
671   if (frontendOptions.needProvenanceRangeToCharBlockMappings)
672     fortranOptions.needProvenanceRangeToCharBlockMappings = true;
673 
674   if (enableConformanceChecks()) {
675     fortranOptions.features.WarnOnAllNonstandard();
676   }
677 }
678 
679 void CompilerInvocation::setSemanticsOpts(
680     Fortran::parser::AllCookedSources &allCookedSources) {
681   const auto &fortranOptions = fortranOpts();
682 
683   semanticsContext_ = std::make_unique<semantics::SemanticsContext>(
684       defaultKinds(), fortranOptions.features, allCookedSources);
685 
686   semanticsContext_->set_moduleDirectory(moduleDir())
687       .set_searchDirectories(fortranOptions.searchDirectories)
688       .set_warnOnNonstandardUsage(enableConformanceChecks())
689       .set_warningsAreErrors(warnAsErr())
690       .set_moduleFileSuffix(moduleFileSuffix());
691 }
692