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