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