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