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/Process.h" 25 #include "llvm/Support/raw_ostream.h" 26 #include <memory> 27 28 using namespace Fortran::frontend; 29 30 //===----------------------------------------------------------------------===// 31 // Initialization. 32 //===----------------------------------------------------------------------===// 33 CompilerInvocationBase::CompilerInvocationBase() 34 : diagnosticOpts_(new clang::DiagnosticOptions()), 35 preprocessorOpts_(new PreprocessorOptions()) {} 36 37 CompilerInvocationBase::CompilerInvocationBase(const CompilerInvocationBase &x) 38 : diagnosticOpts_(new clang::DiagnosticOptions(x.GetDiagnosticOpts())), 39 preprocessorOpts_(new PreprocessorOptions(x.preprocessorOpts())) {} 40 41 CompilerInvocationBase::~CompilerInvocationBase() = default; 42 43 //===----------------------------------------------------------------------===// 44 // Deserialization (from args) 45 //===----------------------------------------------------------------------===// 46 static bool parseShowColorsArgs( 47 const llvm::opt::ArgList &args, bool defaultColor) { 48 // Color diagnostics default to auto ("on" if terminal supports) in the driver 49 // but default to off in cc1, needing an explicit OPT_fdiagnostics_color. 50 // Support both clang's -f[no-]color-diagnostics and gcc's 51 // -f[no-]diagnostics-colors[=never|always|auto]. 52 enum { 53 Colors_On, 54 Colors_Off, 55 Colors_Auto 56 } ShowColors = defaultColor ? Colors_Auto : Colors_Off; 57 58 for (auto *a : args) { 59 const llvm::opt::Option &O = a->getOption(); 60 if (O.matches(clang::driver::options::OPT_fcolor_diagnostics) || 61 O.matches(clang::driver::options::OPT_fdiagnostics_color)) { 62 ShowColors = Colors_On; 63 } else if (O.matches(clang::driver::options::OPT_fno_color_diagnostics) || 64 O.matches(clang::driver::options::OPT_fno_diagnostics_color)) { 65 ShowColors = Colors_Off; 66 } else if (O.matches(clang::driver::options::OPT_fdiagnostics_color_EQ)) { 67 llvm::StringRef value(a->getValue()); 68 if (value == "always") 69 ShowColors = Colors_On; 70 else if (value == "never") 71 ShowColors = Colors_Off; 72 else if (value == "auto") 73 ShowColors = Colors_Auto; 74 } 75 } 76 77 return ShowColors == Colors_On || 78 (ShowColors == Colors_Auto && llvm::sys::Process::StandardErrHasColors()); 79 } 80 81 bool Fortran::frontend::ParseDiagnosticArgs(clang::DiagnosticOptions &opts, 82 llvm::opt::ArgList &args, bool defaultDiagColor) { 83 opts.ShowColors = parseShowColorsArgs(args, defaultDiagColor); 84 85 return true; 86 } 87 88 // Tweak the frontend configuration based on the frontend action 89 static void setUpFrontendBasedOnAction(FrontendOptions &opts) { 90 assert(opts.programAction_ != Fortran::frontend::InvalidAction && 91 "Fortran frontend action not set!"); 92 93 if (opts.programAction_ == DebugDumpParsingLog) 94 opts.instrumentedParse_ = true; 95 } 96 97 static InputKind ParseFrontendArgs(FrontendOptions &opts, 98 llvm::opt::ArgList &args, clang::DiagnosticsEngine &diags) { 99 100 // By default the frontend driver creates a ParseSyntaxOnly action. 101 opts.programAction_ = ParseSyntaxOnly; 102 103 // Identify the action (i.e. opts.ProgramAction) 104 if (const llvm::opt::Arg *a = 105 args.getLastArg(clang::driver::options::OPT_Action_Group)) { 106 switch (a->getOption().getID()) { 107 default: { 108 llvm_unreachable("Invalid option in group!"); 109 } 110 case clang::driver::options::OPT_test_io: 111 opts.programAction_ = InputOutputTest; 112 break; 113 case clang::driver::options::OPT_E: 114 opts.programAction_ = PrintPreprocessedInput; 115 break; 116 case clang::driver::options::OPT_fsyntax_only: 117 opts.programAction_ = ParseSyntaxOnly; 118 break; 119 case clang::driver::options::OPT_emit_obj: 120 opts.programAction_ = EmitObj; 121 break; 122 case clang::driver::options::OPT_fdebug_unparse: 123 opts.programAction_ = DebugUnparse; 124 break; 125 case clang::driver::options::OPT_fdebug_unparse_with_symbols: 126 opts.programAction_ = DebugUnparseWithSymbols; 127 break; 128 case clang::driver::options::OPT_fdebug_dump_symbols: 129 opts.programAction_ = DebugDumpSymbols; 130 break; 131 case clang::driver::options::OPT_fdebug_dump_parse_tree: 132 opts.programAction_ = DebugDumpParseTree; 133 break; 134 case clang::driver::options::OPT_fdebug_dump_provenance: 135 opts.programAction_ = DebugDumpProvenance; 136 break; 137 case clang::driver::options::OPT_fdebug_dump_parsing_log: 138 opts.programAction_ = DebugDumpParsingLog; 139 break; 140 case clang::driver::options::OPT_fdebug_measure_parse_tree: 141 opts.programAction_ = DebugMeasureParseTree; 142 break; 143 case clang::driver::options::OPT_fdebug_pre_fir_tree: 144 opts.programAction_ = DebugPreFIRTree; 145 break; 146 case clang::driver::options::OPT_fget_symbols_sources: 147 opts.programAction_ = GetSymbolsSources; 148 break; 149 150 // TODO: 151 // case calng::driver::options::OPT_emit_llvm: 152 // case clang::driver::options::OPT_emit_llvm_only: 153 // case clang::driver::options::OPT_emit_codegen_only: 154 // case clang::driver::options::OPT_emit_module: 155 // (...) 156 } 157 } 158 159 opts.outputFile_ = args.getLastArgValue(clang::driver::options::OPT_o); 160 opts.showHelp_ = args.hasArg(clang::driver::options::OPT_help); 161 opts.showVersion_ = args.hasArg(clang::driver::options::OPT_version); 162 163 // Get the input kind (from the value passed via `-x`) 164 InputKind dashX(Language::Unknown); 165 if (const llvm::opt::Arg *a = 166 args.getLastArg(clang::driver::options::OPT_x)) { 167 llvm::StringRef XValue = a->getValue(); 168 // Principal languages. 169 dashX = llvm::StringSwitch<InputKind>(XValue) 170 .Case("f90", Language::Fortran) 171 .Default(Language::Unknown); 172 173 // Some special cases cannot be combined with suffixes. 174 if (dashX.IsUnknown()) 175 dashX = llvm::StringSwitch<InputKind>(XValue) 176 .Case("ir", Language::LLVM_IR) 177 .Default(Language::Unknown); 178 179 if (dashX.IsUnknown()) 180 diags.Report(clang::diag::err_drv_invalid_value) 181 << a->getAsString(args) << a->getValue(); 182 } 183 184 // Collect the input files and save them in our instance of FrontendOptions. 185 std::vector<std::string> inputs = 186 args.getAllArgValues(clang::driver::options::OPT_INPUT); 187 opts.inputs_.clear(); 188 if (inputs.empty()) 189 // '-' is the default input if none is given. 190 inputs.push_back("-"); 191 for (unsigned i = 0, e = inputs.size(); i != e; ++i) { 192 InputKind ik = dashX; 193 if (ik.IsUnknown()) { 194 ik = FrontendOptions::GetInputKindForExtension( 195 llvm::StringRef(inputs[i]).rsplit('.').second); 196 if (ik.IsUnknown()) 197 ik = Language::Unknown; 198 if (i == 0) 199 dashX = ik; 200 } 201 202 opts.inputs_.emplace_back(std::move(inputs[i]), ik); 203 } 204 205 // Set fortranForm_ based on options -ffree-form and -ffixed-form. 206 if (const auto *arg = args.getLastArg(clang::driver::options::OPT_ffixed_form, 207 clang::driver::options::OPT_ffree_form)) { 208 opts.fortranForm_ = 209 arg->getOption().matches(clang::driver::options::OPT_ffixed_form) 210 ? FortranForm::FixedForm 211 : FortranForm::FreeForm; 212 } 213 214 // Set fixedFormColumns_ based on -ffixed-line-length=<value> 215 if (const auto *arg = 216 args.getLastArg(clang::driver::options::OPT_ffixed_line_length_EQ)) { 217 llvm::StringRef argValue = llvm::StringRef(arg->getValue()); 218 std::int64_t columns = -1; 219 if (argValue == "none") { 220 columns = 0; 221 } else if (argValue.getAsInteger(/*Radix=*/10, columns)) { 222 columns = -1; 223 } 224 if (columns < 0) { 225 diags.Report(clang::diag::err_drv_invalid_value_with_suggestion) 226 << arg->getOption().getName() << arg->getValue() 227 << "value must be 'none' or a non-negative integer"; 228 } else if (columns == 0) { 229 opts.fixedFormColumns_ = 1000000; 230 } else if (columns < 7) { 231 diags.Report(clang::diag::err_drv_invalid_value_with_suggestion) 232 << arg->getOption().getName() << arg->getValue() 233 << "value must be at least seven"; 234 } else { 235 opts.fixedFormColumns_ = columns; 236 } 237 } 238 239 if (const llvm::opt::Arg *arg = 240 args.getLastArg(clang::driver::options::OPT_fimplicit_none, 241 clang::driver::options::OPT_fno_implicit_none)) { 242 opts.features_.Enable( 243 Fortran::common::LanguageFeature::ImplicitNoneTypeAlways, 244 arg->getOption().matches(clang::driver::options::OPT_fimplicit_none)); 245 } 246 if (const llvm::opt::Arg *arg = 247 args.getLastArg(clang::driver::options::OPT_fbackslash, 248 clang::driver::options::OPT_fno_backslash)) { 249 opts.features_.Enable(Fortran::common::LanguageFeature::BackslashEscapes, 250 arg->getOption().matches(clang::driver::options::OPT_fbackslash)); 251 } 252 if (const llvm::opt::Arg *arg = 253 args.getLastArg(clang::driver::options::OPT_flogical_abbreviations, 254 clang::driver::options::OPT_fno_logical_abbreviations)) { 255 opts.features_.Enable( 256 Fortran::common::LanguageFeature::LogicalAbbreviations, 257 arg->getOption().matches( 258 clang::driver::options::OPT_flogical_abbreviations)); 259 } 260 if (const llvm::opt::Arg *arg = 261 args.getLastArg(clang::driver::options::OPT_fxor_operator, 262 clang::driver::options::OPT_fno_xor_operator)) { 263 opts.features_.Enable(Fortran::common::LanguageFeature::XOROperator, 264 arg->getOption().matches(clang::driver::options::OPT_fxor_operator)); 265 } 266 if (args.hasArg( 267 clang::driver::options::OPT_falternative_parameter_statement)) { 268 opts.features_.Enable(Fortran::common::LanguageFeature::OldStyleParameter); 269 } 270 if (const llvm::opt::Arg *arg = 271 args.getLastArg(clang::driver::options::OPT_finput_charset_EQ)) { 272 llvm::StringRef argValue = arg->getValue(); 273 if (argValue == "utf-8") { 274 opts.encoding_ = Fortran::parser::Encoding::UTF_8; 275 } else if (argValue == "latin-1") { 276 opts.encoding_ = Fortran::parser::Encoding::LATIN_1; 277 } else { 278 diags.Report(clang::diag::err_drv_invalid_value) 279 << arg->getAsString(args) << argValue; 280 } 281 } 282 283 setUpFrontendBasedOnAction(opts); 284 285 return dashX; 286 } 287 288 /// Parses all preprocessor input arguments and populates the preprocessor 289 /// options accordingly. 290 /// 291 /// \param [in] opts The preprocessor options instance 292 /// \param [out] args The list of input arguments 293 static void parsePreprocessorArgs( 294 Fortran::frontend::PreprocessorOptions &opts, llvm::opt::ArgList &args) { 295 // Add macros from the command line. 296 for (const auto *currentArg : args.filtered( 297 clang::driver::options::OPT_D, clang::driver::options::OPT_U)) { 298 if (currentArg->getOption().matches(clang::driver::options::OPT_D)) { 299 opts.addMacroDef(currentArg->getValue()); 300 } else { 301 opts.addMacroUndef(currentArg->getValue()); 302 } 303 } 304 305 // Add the ordered list of -I's. 306 for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I)) 307 opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue()); 308 } 309 310 /// Parses all semantic related arguments and populates the variables 311 /// options accordingly. 312 static void parseSemaArgs(CompilerInvocation &res, llvm::opt::ArgList &args, 313 clang::DiagnosticsEngine &diags) { 314 315 // -J/module-dir option 316 auto moduleDirList = 317 args.getAllArgValues(clang::driver::options::OPT_module_dir); 318 // User can only specify -J/-module-dir once 319 // https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html 320 if (moduleDirList.size() > 1) { 321 const unsigned diagID = 322 diags.getCustomDiagID(clang::DiagnosticsEngine::Error, 323 "Only one '-module-dir/-J' option allowed"); 324 diags.Report(diagID); 325 } 326 if (moduleDirList.size() == 1) 327 res.SetModuleDir(moduleDirList[0]); 328 329 // -fdebug-module-writer option 330 if (args.hasArg(clang::driver::options::OPT_fdebug_module_writer)) { 331 res.SetDebugModuleDir(true); 332 } 333 } 334 335 /// Parses all Dialect related arguments and populates the variables 336 /// options accordingly. 337 static void parseDialectArgs(CompilerInvocation &res, llvm::opt::ArgList &args, 338 clang::DiagnosticsEngine &diags) { 339 340 // -fdefault* family 341 if (args.hasArg(clang::driver::options::OPT_fdefault_real_8)) { 342 res.defaultKinds().set_defaultRealKind(8); 343 res.defaultKinds().set_doublePrecisionKind(16); 344 } 345 if (args.hasArg(clang::driver::options::OPT_fdefault_integer_8)) { 346 res.defaultKinds().set_defaultIntegerKind(8); 347 res.defaultKinds().set_subscriptIntegerKind(8); 348 res.defaultKinds().set_sizeIntegerKind(8); 349 } 350 if (args.hasArg(clang::driver::options::OPT_fdefault_double_8)) { 351 if (!args.hasArg(clang::driver::options::OPT_fdefault_real_8)) { 352 // -fdefault-double-8 has to be used with -fdefault-real-8 353 // to be compatible with gfortran 354 const unsigned diagID = 355 diags.getCustomDiagID(clang::DiagnosticsEngine::Error, 356 "Use of `-fdefault-double-8` requires `-fdefault-real-8`"); 357 diags.Report(diagID); 358 } 359 // https://gcc.gnu.org/onlinedocs/gfortran/Fortran-Dialect-Options.html 360 res.defaultKinds().set_doublePrecisionKind(8); 361 } 362 if (args.hasArg(clang::driver::options::OPT_flarge_sizes)) 363 res.defaultKinds().set_sizeIntegerKind(8); 364 365 // -fopenmp and -fopenacc 366 if (args.hasArg(clang::driver::options::OPT_fopenacc)) { 367 res.frontendOpts().features_.Enable( 368 Fortran::common::LanguageFeature::OpenACC); 369 } 370 if (args.hasArg(clang::driver::options::OPT_fopenmp)) { 371 res.frontendOpts().features_.Enable( 372 Fortran::common::LanguageFeature::OpenMP); 373 } 374 return; 375 } 376 377 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res, 378 llvm::ArrayRef<const char *> commandLineArgs, 379 clang::DiagnosticsEngine &diags) { 380 381 bool success = true; 382 383 // Parse the arguments 384 const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable(); 385 const unsigned includedFlagsBitmask = clang::driver::options::FC1Option; 386 unsigned missingArgIndex, missingArgCount; 387 llvm::opt::InputArgList args = opts.ParseArgs( 388 commandLineArgs, missingArgIndex, missingArgCount, includedFlagsBitmask); 389 390 // Issue errors on unknown arguments 391 for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) { 392 auto argString = a->getAsString(args); 393 std::string nearest; 394 if (opts.findNearest(argString, nearest, includedFlagsBitmask) > 1) 395 diags.Report(clang::diag::err_drv_unknown_argument) << argString; 396 else 397 diags.Report(clang::diag::err_drv_unknown_argument_with_suggestion) 398 << argString << nearest; 399 success = false; 400 } 401 402 // Parse the frontend args 403 ParseFrontendArgs(res.frontendOpts(), args, diags); 404 // Parse the preprocessor args 405 parsePreprocessorArgs(res.preprocessorOpts(), args); 406 // Parse semantic args 407 parseSemaArgs(res, args, diags); 408 // Parse dialect arguments 409 parseDialectArgs(res, args, diags); 410 411 return success; 412 } 413 414 /// Collect the macro definitions provided by the given preprocessor 415 /// options into the parser options. 416 /// 417 /// \param [in] ppOpts The preprocessor options 418 /// \param [out] opts The fortran options 419 static void collectMacroDefinitions( 420 const PreprocessorOptions &ppOpts, Fortran::parser::Options &opts) { 421 for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) { 422 llvm::StringRef macro = ppOpts.macros[i].first; 423 bool isUndef = ppOpts.macros[i].second; 424 425 std::pair<llvm::StringRef, llvm::StringRef> macroPair = macro.split('='); 426 llvm::StringRef macroName = macroPair.first; 427 llvm::StringRef macroBody = macroPair.second; 428 429 // For an #undef'd macro, we only care about the name. 430 if (isUndef) { 431 opts.predefinitions.emplace_back( 432 macroName.str(), std::optional<std::string>{}); 433 continue; 434 } 435 436 // For a #define'd macro, figure out the actual definition. 437 if (macroName.size() == macro.size()) 438 macroBody = "1"; 439 else { 440 // Note: GCC drops anything following an end-of-line character. 441 llvm::StringRef::size_type End = macroBody.find_first_of("\n\r"); 442 macroBody = macroBody.substr(0, End); 443 } 444 opts.predefinitions.emplace_back( 445 macroName, std::optional<std::string>(macroBody.str())); 446 } 447 } 448 449 void CompilerInvocation::SetDefaultFortranOpts() { 450 auto &fortranOptions = fortranOpts(); 451 452 // These defaults are based on the defaults in f18/f18.cpp. 453 std::vector<std::string> searchDirectories{"."s}; 454 fortranOptions.searchDirectories = searchDirectories; 455 fortranOptions.isFixedForm = false; 456 } 457 458 // TODO: When expanding this method, consider creating a dedicated API for 459 // this. Also at some point we will need to differentiate between different 460 // targets and add dedicated predefines for each. 461 void CompilerInvocation::setDefaultPredefinitions() { 462 auto &fortranOptions = fortranOpts(); 463 const auto &frontendOptions = frontendOpts(); 464 465 // Populate the macro list with version numbers and other predefinitions. 466 fortranOptions.predefinitions.emplace_back("__flang__", "1"); 467 fortranOptions.predefinitions.emplace_back( 468 "__flang_major__", FLANG_VERSION_MAJOR_STRING); 469 fortranOptions.predefinitions.emplace_back( 470 "__flang_minor__", FLANG_VERSION_MINOR_STRING); 471 fortranOptions.predefinitions.emplace_back( 472 "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING); 473 474 // Add predefinitions based on extensions enabled 475 if (frontendOptions.features_.IsEnabled( 476 Fortran::common::LanguageFeature::OpenACC)) { 477 fortranOptions.predefinitions.emplace_back("_OPENACC", "202011"); 478 } 479 if (frontendOptions.features_.IsEnabled( 480 Fortran::common::LanguageFeature::OpenMP)) { 481 fortranOptions.predefinitions.emplace_back("_OPENMP", "201511"); 482 } 483 } 484 485 void CompilerInvocation::setFortranOpts() { 486 auto &fortranOptions = fortranOpts(); 487 const auto &frontendOptions = frontendOpts(); 488 const auto &preprocessorOptions = preprocessorOpts(); 489 auto &moduleDirJ = moduleDir(); 490 491 if (frontendOptions.fortranForm_ != FortranForm::Unknown) { 492 fortranOptions.isFixedForm = 493 frontendOptions.fortranForm_ == FortranForm::FixedForm; 494 } 495 fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_; 496 497 fortranOptions.features = frontendOptions.features_; 498 fortranOptions.encoding = frontendOptions.encoding_; 499 500 collectMacroDefinitions(preprocessorOptions, fortranOptions); 501 502 fortranOptions.searchDirectories.insert( 503 fortranOptions.searchDirectories.end(), 504 preprocessorOptions.searchDirectoriesFromDashI.begin(), 505 preprocessorOptions.searchDirectoriesFromDashI.end()); 506 507 // Add the directory supplied through -J/-module-dir to the list of search 508 // directories 509 if (moduleDirJ.compare(".") != 0) 510 fortranOptions.searchDirectories.emplace_back(moduleDirJ); 511 512 if (frontendOptions.instrumentedParse_) 513 fortranOptions.instrumentedParse = true; 514 } 515 516 void CompilerInvocation::setSemanticsOpts( 517 Fortran::parser::AllCookedSources &allCookedSources) { 518 const auto &fortranOptions = fortranOpts(); 519 520 semanticsContext_ = std::make_unique<semantics::SemanticsContext>( 521 defaultKinds(), fortranOptions.features, allCookedSources); 522 523 semanticsContext_->set_moduleDirectory(moduleDir()) 524 .set_searchDirectories(fortranOptions.searchDirectories); 525 } 526