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 // Extensions 225 if (args.hasArg(clang::driver::options::OPT_fopenacc)) { 226 opts.features_.Enable(Fortran::common::LanguageFeature::OpenACC); 227 } 228 if (args.hasArg(clang::driver::options::OPT_fopenmp)) { 229 opts.features_.Enable(Fortran::common::LanguageFeature::OpenMP); 230 } 231 if (const llvm::opt::Arg *arg = 232 args.getLastArg(clang::driver::options::OPT_fimplicit_none, 233 clang::driver::options::OPT_fno_implicit_none)) { 234 opts.features_.Enable( 235 Fortran::common::LanguageFeature::ImplicitNoneTypeAlways, 236 arg->getOption().matches(clang::driver::options::OPT_fimplicit_none)); 237 } 238 if (const llvm::opt::Arg *arg = 239 args.getLastArg(clang::driver::options::OPT_fbackslash, 240 clang::driver::options::OPT_fno_backslash)) { 241 opts.features_.Enable(Fortran::common::LanguageFeature::BackslashEscapes, 242 arg->getOption().matches(clang::driver::options::OPT_fbackslash)); 243 } 244 if (const llvm::opt::Arg *arg = 245 args.getLastArg(clang::driver::options::OPT_flogical_abbreviations, 246 clang::driver::options::OPT_fno_logical_abbreviations)) { 247 opts.features_.Enable( 248 Fortran::common::LanguageFeature::LogicalAbbreviations, 249 arg->getOption().matches( 250 clang::driver::options::OPT_flogical_abbreviations)); 251 } 252 if (const llvm::opt::Arg *arg = 253 args.getLastArg(clang::driver::options::OPT_fxor_operator, 254 clang::driver::options::OPT_fno_xor_operator)) { 255 opts.features_.Enable(Fortran::common::LanguageFeature::XOROperator, 256 arg->getOption().matches(clang::driver::options::OPT_fxor_operator)); 257 } 258 if (args.hasArg( 259 clang::driver::options::OPT_falternative_parameter_statement)) { 260 opts.features_.Enable(Fortran::common::LanguageFeature::OldStyleParameter); 261 } 262 if (const llvm::opt::Arg *arg = 263 args.getLastArg(clang::driver::options::OPT_finput_charset_EQ)) { 264 llvm::StringRef argValue = arg->getValue(); 265 if (argValue == "utf-8") { 266 opts.encoding_ = Fortran::parser::Encoding::UTF_8; 267 } else if (argValue == "latin-1") { 268 opts.encoding_ = Fortran::parser::Encoding::LATIN_1; 269 } else { 270 diags.Report(clang::diag::err_drv_invalid_value) 271 << arg->getAsString(args) << argValue; 272 } 273 } 274 return dashX; 275 } 276 277 /// Parses all preprocessor input arguments and populates the preprocessor 278 /// options accordingly. 279 /// 280 /// \param [in] opts The preprocessor options instance 281 /// \param [out] args The list of input arguments 282 static void parsePreprocessorArgs( 283 Fortran::frontend::PreprocessorOptions &opts, llvm::opt::ArgList &args) { 284 // Add macros from the command line. 285 for (const auto *currentArg : args.filtered( 286 clang::driver::options::OPT_D, clang::driver::options::OPT_U)) { 287 if (currentArg->getOption().matches(clang::driver::options::OPT_D)) { 288 opts.addMacroDef(currentArg->getValue()); 289 } else { 290 opts.addMacroUndef(currentArg->getValue()); 291 } 292 } 293 294 // Add the ordered list of -I's. 295 for (const auto *currentArg : args.filtered(clang::driver::options::OPT_I)) 296 opts.searchDirectoriesFromDashI.emplace_back(currentArg->getValue()); 297 } 298 299 /// Parses all semantic related arguments and populates the variables 300 /// options accordingly. 301 static void parseSemaArgs(std::string &moduleDir, llvm::opt::ArgList &args, 302 clang::DiagnosticsEngine &diags) { 303 304 auto moduleDirList = 305 args.getAllArgValues(clang::driver::options::OPT_module_dir); 306 // User can only specify -J/-module-dir once 307 // https://gcc.gnu.org/onlinedocs/gfortran/Directory-Options.html 308 if (moduleDirList.size() > 1) { 309 const unsigned diagID = 310 diags.getCustomDiagID(clang::DiagnosticsEngine::Error, 311 "Only one '-module-dir/-J' option allowed"); 312 diags.Report(diagID); 313 } 314 if (moduleDirList.size() == 1) 315 moduleDir = moduleDirList[0]; 316 } 317 318 bool CompilerInvocation::CreateFromArgs(CompilerInvocation &res, 319 llvm::ArrayRef<const char *> commandLineArgs, 320 clang::DiagnosticsEngine &diags) { 321 322 bool success = true; 323 324 // Parse the arguments 325 const llvm::opt::OptTable &opts = clang::driver::getDriverOptTable(); 326 const unsigned includedFlagsBitmask = clang::driver::options::FC1Option; 327 unsigned missingArgIndex, missingArgCount; 328 llvm::opt::InputArgList args = opts.ParseArgs( 329 commandLineArgs, missingArgIndex, missingArgCount, includedFlagsBitmask); 330 331 // Issue errors on unknown arguments 332 for (const auto *a : args.filtered(clang::driver::options::OPT_UNKNOWN)) { 333 auto argString = a->getAsString(args); 334 std::string nearest; 335 if (opts.findNearest(argString, nearest, includedFlagsBitmask) > 1) 336 diags.Report(clang::diag::err_drv_unknown_argument) << argString; 337 else 338 diags.Report(clang::diag::err_drv_unknown_argument_with_suggestion) 339 << argString << nearest; 340 success = false; 341 } 342 343 // Parse the frontend args 344 ParseFrontendArgs(res.frontendOpts(), args, diags); 345 // Parse the preprocessor args 346 parsePreprocessorArgs(res.preprocessorOpts(), args); 347 // Parse semantic args 348 parseSemaArgs(res.moduleDir(), args, diags); 349 350 return success; 351 } 352 353 /// Collect the macro definitions provided by the given preprocessor 354 /// options into the parser options. 355 /// 356 /// \param [in] ppOpts The preprocessor options 357 /// \param [out] opts The fortran options 358 static void collectMacroDefinitions( 359 const PreprocessorOptions &ppOpts, Fortran::parser::Options &opts) { 360 for (unsigned i = 0, n = ppOpts.macros.size(); i != n; ++i) { 361 llvm::StringRef macro = ppOpts.macros[i].first; 362 bool isUndef = ppOpts.macros[i].second; 363 364 std::pair<llvm::StringRef, llvm::StringRef> macroPair = macro.split('='); 365 llvm::StringRef macroName = macroPair.first; 366 llvm::StringRef macroBody = macroPair.second; 367 368 // For an #undef'd macro, we only care about the name. 369 if (isUndef) { 370 opts.predefinitions.emplace_back( 371 macroName.str(), std::optional<std::string>{}); 372 continue; 373 } 374 375 // For a #define'd macro, figure out the actual definition. 376 if (macroName.size() == macro.size()) 377 macroBody = "1"; 378 else { 379 // Note: GCC drops anything following an end-of-line character. 380 llvm::StringRef::size_type End = macroBody.find_first_of("\n\r"); 381 macroBody = macroBody.substr(0, End); 382 } 383 opts.predefinitions.emplace_back( 384 macroName, std::optional<std::string>(macroBody.str())); 385 } 386 } 387 388 void CompilerInvocation::SetDefaultFortranOpts() { 389 auto &fortranOptions = fortranOpts(); 390 391 // These defaults are based on the defaults in f18/f18.cpp. 392 std::vector<std::string> searchDirectories{"."s}; 393 fortranOptions.searchDirectories = searchDirectories; 394 fortranOptions.isFixedForm = false; 395 } 396 397 // TODO: When expanding this method, consider creating a dedicated API for 398 // this. Also at some point we will need to differentiate between different 399 // targets and add dedicated predefines for each. 400 void CompilerInvocation::setDefaultPredefinitions() { 401 auto &fortranOptions = fortranOpts(); 402 const auto &frontendOptions = frontendOpts(); 403 404 // Populate the macro list with version numbers and other predefinitions. 405 fortranOptions.predefinitions.emplace_back("__flang__", "1"); 406 fortranOptions.predefinitions.emplace_back( 407 "__flang_major__", FLANG_VERSION_MAJOR_STRING); 408 fortranOptions.predefinitions.emplace_back( 409 "__flang_minor__", FLANG_VERSION_MINOR_STRING); 410 fortranOptions.predefinitions.emplace_back( 411 "__flang_patchlevel__", FLANG_VERSION_PATCHLEVEL_STRING); 412 413 // Add predefinitions based on extensions enabled 414 if (frontendOptions.features_.IsEnabled( 415 Fortran::common::LanguageFeature::OpenACC)) { 416 fortranOptions.predefinitions.emplace_back("_OPENACC", "202011"); 417 } 418 if (frontendOptions.features_.IsEnabled( 419 Fortran::common::LanguageFeature::OpenMP)) { 420 fortranOptions.predefinitions.emplace_back("_OPENMP", "201511"); 421 } 422 } 423 424 void CompilerInvocation::setFortranOpts() { 425 auto &fortranOptions = fortranOpts(); 426 const auto &frontendOptions = frontendOpts(); 427 const auto &preprocessorOptions = preprocessorOpts(); 428 auto &moduleDirJ = moduleDir(); 429 430 if (frontendOptions.fortranForm_ != FortranForm::Unknown) { 431 fortranOptions.isFixedForm = 432 frontendOptions.fortranForm_ == FortranForm::FixedForm; 433 } 434 fortranOptions.fixedFormColumns = frontendOptions.fixedFormColumns_; 435 436 fortranOptions.features = frontendOptions.features_; 437 fortranOptions.encoding = frontendOptions.encoding_; 438 439 collectMacroDefinitions(preprocessorOptions, fortranOptions); 440 441 fortranOptions.searchDirectories.insert( 442 fortranOptions.searchDirectories.end(), 443 preprocessorOptions.searchDirectoriesFromDashI.begin(), 444 preprocessorOptions.searchDirectoriesFromDashI.end()); 445 446 // Add the directory supplied through -J/-module-dir to the list of search 447 // directories 448 if (moduleDirJ.compare(".") != 0) 449 fortranOptions.searchDirectories.emplace_back(moduleDirJ); 450 } 451 452 void CompilerInvocation::setSemanticsOpts( 453 Fortran::parser::AllCookedSources &allCookedSources) { 454 const auto &fortranOptions = fortranOpts(); 455 456 semanticsContext_ = std::make_unique<semantics::SemanticsContext>( 457 *(new Fortran::common::IntrinsicTypeDefaultKinds()), 458 fortranOptions.features, allCookedSources); 459 460 auto &moduleDirJ = moduleDir(); 461 semanticsContext_->set_moduleDirectory(moduleDirJ) 462 .set_searchDirectories(fortranOptions.searchDirectories); 463 } 464