bool FrontendInputs::verifyInputs(DiagnosticEngine &diags, bool treatAsSIL, bool isREPLRequested, bool isNoneRequested) const { if (isREPLRequested) { if (hasInputs()) { diags.diagnose(SourceLoc(), diag::error_repl_requires_no_input_files); return true; } } else if (treatAsSIL) { if (isWholeModule()) { if (inputCount() != 1) { diags.diagnose(SourceLoc(), diag::error_mode_requires_one_input_file); return true; } } else { assertMustNotBeMoreThanOnePrimaryInput(); // If we have the SIL as our primary input, we can waive the one file // requirement as long as all the other inputs are SIBs. if (!areAllNonPrimariesSIB()) { diags.diagnose(SourceLoc(), diag::error_mode_requires_one_sil_multi_sib); return true; } } } else if (!isNoneRequested && !hasInputs()) { diags.diagnose(SourceLoc(), diag::error_mode_requires_an_input_file); return true; } return false; }
OptionSet<SanitizerKind> swift::parseSanitizerArgValues( const llvm::opt::ArgList &Args, const llvm::opt::Arg *A, const llvm::Triple &Triple, DiagnosticEngine &Diags, llvm::function_ref<bool(llvm::StringRef)> sanitizerRuntimeLibExists) { OptionSet<SanitizerKind> sanitizerSet; // Find the sanitizer kind. for (int i = 0, n = A->getNumValues(); i != n; ++i) { StringRef opt = A->getValue(i); if (opt == "address") { sanitizerSet |= SanitizerKind::Address; } else if (opt == "thread") { sanitizerSet |= SanitizerKind::Thread; } else if (opt == "fuzzer") { sanitizerSet |= SanitizerKind::Fuzzer; } else { Diags.diagnose(SourceLoc(), diag::error_unsupported_option_argument, A->getOption().getPrefixedName(), A->getValue(i)); } } // Sanitizers are only supported on Linux or Darwin. if (!(Triple.isOSDarwin() || Triple.isOSLinux())) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + StringRef(A->getAsString(Args))).toStringRef(b), Triple.getTriple()); } // Address and thread sanitizers can not be enabled concurrently. if ((sanitizerSet & SanitizerKind::Thread) && (sanitizerSet & SanitizerKind::Address)) { SmallString<128> b1; SmallString<128> b2; Diags.diagnose(SourceLoc(), diag::error_argument_not_allowed_with, (A->getOption().getPrefixedName() + toStringRef(SanitizerKind::Address)).toStringRef(b1), (A->getOption().getPrefixedName() + toStringRef(SanitizerKind::Thread)).toStringRef(b2)); } // Thread Sanitizer only works on OS X and the simulators. It's only supported // on 64 bit architectures. if ((sanitizerSet & SanitizerKind::Thread) && !isTSanSupported(Triple, sanitizerRuntimeLibExists)) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + toStringRef(SanitizerKind::Thread)).toStringRef(b), Triple.getTriple()); } return sanitizerSet; }
SanitizerKind swift::parseSanitizerArgValues(const llvm::opt::Arg *A, const llvm::Triple &Triple, DiagnosticEngine &Diags) { SanitizerKind kind = SanitizerKind::None; // Find the sanitizer kind. SanitizerKind pKind = SanitizerKind::None; for (int i = 0, n = A->getNumValues(); i != n; ++i) { kind = llvm::StringSwitch<SanitizerKind>(A->getValue(i)) .Case("address", SanitizerKind::Address) .Case("thread", SanitizerKind::Thread) .Default(SanitizerKind::None); if (kind == SanitizerKind::None) { Diags.diagnose(SourceLoc(), diag::error_unsupported_option_argument, A->getOption().getPrefixedName(), A->getValue(i)); return kind; } // Currently, more than one sanitizer cannot be enabled at the same time. if (pKind != SanitizerKind::None && pKind != kind) { SmallString<128> pb; SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_argument_not_allowed_with, (A->getOption().getPrefixedName() + toStringRef(pKind)).toStringRef(pb), (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b)); } pKind = kind; } if (kind == SanitizerKind::None) return kind; // Check if the target is supported for this sanitizer. // None of the sanitizers work on Linux right now. if (!Triple.isOSDarwin()) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b), Triple.getTriple()); } // Thread Sanitizer only works on OS X and the simulators. It's only supported // on 64 bit architectures. if (kind == SanitizerKind::Thread && (!(Triple.isMacOSX() || tripleIsAnySimulator(Triple)) || !Triple.isArch64Bit())) { SmallString<128> b; Diags.diagnose(SourceLoc(), diag::error_unsupported_opt_for_target, (A->getOption().getPrefixedName() + toStringRef(kind)).toStringRef(b), Triple.getTriple()); } return kind; }
static bool validateSymbolSet(DiagnosticEngine &diags, llvm::StringSet<> symbols, llvm::Module &IRModule, bool diagnoseExtraSymbolsInTBD) { auto error = false; // Diff the two sets of symbols, flagging anything outside their intersection. // Delay the emission of errors for things in the IR but not TBD, so we can // sort them to get a stable order. std::vector<StringRef> irNotTBD; for (auto &nameValue : IRModule.getValueSymbolTable()) { auto name = nameValue.getKey(); auto value = nameValue.getValue(); if (auto GV = dyn_cast<llvm::GlobalValue>(value)) { // Is this a symbol that should be listed? auto externallyVisible = GV->hasExternalLinkage() && !GV->hasHiddenVisibility(); if (!GV->isDeclaration() && externallyVisible) { // Is it listed? if (!symbols.erase(name)) irNotTBD.push_back(name); } } else { assert(symbols.find(name) == symbols.end() && "non-global value in value symbol table"); } } std::sort(irNotTBD.begin(), irNotTBD.end()); for (auto &name : irNotTBD) { diags.diagnose(SourceLoc(), diag::symbol_in_ir_not_in_tbd, name, Demangle::demangleSymbolAsString(name)); error = true; } if (diagnoseExtraSymbolsInTBD) { // Look for any extra symbols. for (auto &name : sortSymbols(symbols)) { diags.diagnose(SourceLoc(), diag::symbol_in_tbd_not_in_ir, name, Demangle::demangleSymbolAsString(name)); error = true; } } if (error) { diags.diagnose(SourceLoc(), diag::tbd_validation_failure); } return error; }
int parseArgs(llvm::ArrayRef<const char *> Args, DiagnosticEngine &Diags) { using namespace options; // Parse frontend command line options using Swift's option table. std::unique_ptr<llvm::opt::OptTable> Table = createSwiftOptTable(); unsigned MissingIndex; unsigned MissingCount; llvm::opt::InputArgList ParsedArgs = Table->ParseArgs(Args, MissingIndex, MissingCount, ModuleWrapOption); if (MissingCount) { Diags.diagnose(SourceLoc(), diag::error_missing_arg_value, ParsedArgs.getArgString(MissingIndex), MissingCount); return 1; } if (const Arg *A = ParsedArgs.getLastArg(options::OPT_target)) TargetTriple = llvm::Triple(llvm::Triple::normalize(A->getValue())); else TargetTriple = llvm::Triple(llvm::sys::getDefaultTargetTriple()); if (ParsedArgs.hasArg(OPT_UNKNOWN)) { for (const Arg *A : ParsedArgs.filtered(OPT_UNKNOWN)) { Diags.diagnose(SourceLoc(), diag::error_unknown_arg, A->getAsString(ParsedArgs)); } return true; } if (ParsedArgs.getLastArg(OPT_help)) { std::string ExecutableName = llvm::sys::path::stem(MainExecutablePath); Table->PrintHelp(llvm::outs(), ExecutableName.c_str(), "Swift Module Wrapper", options::ModuleWrapOption, 0); return 1; } for (const Arg *A : ParsedArgs.filtered(OPT_INPUT)) { InputFilenames.push_back(A->getValue()); } if (InputFilenames.empty()) { Diags.diagnose(SourceLoc(), diag::error_mode_requires_an_input_file); return 1; } if (const Arg *A = ParsedArgs.getLastArg(OPT_o)) { OutputFilename = A->getValue(); } return 0; }
std::unique_ptr<CompilerInvocation> swift::driver::createCompilerInvocation(ArrayRef<const char *> ArgList, DiagnosticEngine &Diags) { SmallVector<const char *, 16> Args; Args.push_back("<swiftc>"); // FIXME: Remove dummy argument. Args.insert(Args.end(), ArgList.begin(), ArgList.end()); // When creating a CompilerInvocation, ensure that the driver creates a single // frontend command. Args.push_back("-force-single-frontend-invocation"); // Force the driver into batch mode by specifying "swiftc" as the name. Driver TheDriver("swiftc", "swiftc", Args, Diags); // Don't check for the existence of input files, since the user of the // CompilerInvocation may wish to remap inputs to source buffers. TheDriver.setCheckInputFilesExist(false); std::unique_ptr<Compilation> C = TheDriver.buildCompilation(Args); if (!C || C->getJobs().empty()) return nullptr; // Don't emit an error; one should already have been emitted SmallPtrSet<const Job *, 4> CompileCommands; for (const Job *Cmd : C->getJobs()) if (isa<CompileJobAction>(Cmd->getSource())) CompileCommands.insert(Cmd); if (CompileCommands.size() != 1) { // TODO: include Jobs in the diagnostic. Diags.diagnose(SourceLoc(), diag::error_expected_one_frontend_job); return nullptr; } const Job *Cmd = *CompileCommands.begin(); if (StringRef("-frontend") != Cmd->getArguments().front()) { Diags.diagnose(SourceLoc(), diag::error_expected_frontend_command); return nullptr; } std::unique_ptr<CompilerInvocation> Invocation(new CompilerInvocation()); const llvm::opt::ArgStringList &BaseFrontendArgs = Cmd->getArguments(); ArrayRef<const char *> FrontendArgs = llvm::makeArrayRef(BaseFrontendArgs.data() + 1, BaseFrontendArgs.data() + BaseFrontendArgs.size()); if (Invocation->parseArgs(FrontendArgs, Diags)) return nullptr; // Don't emit an error; one should already have been emitted return Invocation; }
/// Parse -enforce-exclusivity=... options void parseExclusivityEnforcementOptions(const llvm::opt::Arg *A, SILOptions &Opts, DiagnosticEngine &Diags) { StringRef Argument = A->getValue(); if (Argument == "unchecked") { // This option is analogous to the -Ounchecked optimization setting. // It will disable dynamic checking but still diagnose statically. Opts.EnforceExclusivityStatic = true; Opts.EnforceExclusivityDynamic = false; } else if (Argument == "checked") { Opts.EnforceExclusivityStatic = true; Opts.EnforceExclusivityDynamic = true; } else if (Argument == "dynamic-only") { // This option is intended for staging purposes. The intent is that // it will eventually be removed. Opts.EnforceExclusivityStatic = false; Opts.EnforceExclusivityDynamic = true; } else if (Argument == "none") { // This option is for staging purposes. Opts.EnforceExclusivityStatic = false; Opts.EnforceExclusivityDynamic = false; } else { Diags.diagnose(SourceLoc(), diag::error_unsupported_option_argument, A->getOption().getPrefixedName(), A->getValue()); } }
int getTokensFromFile(unsigned BufferID, LangOptions &LangOpts, SourceManager &SourceMgr, DiagnosticEngine &Diags, std::vector<std::pair<RC<syntax::TokenSyntax>, syntax::AbsolutePosition>> &Tokens) { Tokens = tokenizeWithTrivia(LangOpts, SourceMgr, BufferID); return Diags.hadAnyError() ? EXIT_FAILURE : EXIT_SUCCESS; }
static void diagnoseSwiftVersion(Optional<version::Version> &vers, Arg *verArg, ArgList &Args, DiagnosticEngine &diags) { // General invalid version error diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, verArg->getAsString(Args), verArg->getValue()); // Check for an unneeded minor version, otherwise just list valid versions if (vers.hasValue() && !vers.getValue().empty() && vers.getValue().asMajorVersion().getEffectiveLanguageVersion()) { diags.diagnose(SourceLoc(), diag::note_swift_version_major, vers.getValue()[0]); } else { // Note valid versions instead auto validVers = version::Version::getValidEffectiveVersions(); auto versStr = "'" + llvm::join(validVers.begin(), validVers.end(), "', '") + "'"; diags.diagnose(SourceLoc(), diag::note_valid_swift_versions, versStr); } }
/// \brief Create a new Regex instance out of the string value in \p RpassArg. /// It returns a pointer to the newly generated Regex instance. static std::shared_ptr<llvm::Regex> generateOptimizationRemarkRegex(DiagnosticEngine &Diags, ArgList &Args, Arg *RpassArg) { StringRef Val = RpassArg->getValue(); std::string RegexError; std::shared_ptr<llvm::Regex> Pattern = std::make_shared<llvm::Regex>(Val); if (!Pattern->isValid(RegexError)) { Diags.diagnose(SourceLoc(), diag::error_optimization_remark_pattern, RegexError, RpassArg->getAsString(Args)); Pattern.reset(); } return Pattern; }
static void checkForOutOfDateInputs(DiagnosticEngine &diags, const InputInfoMap &inputs) { for (const auto &inputPair : inputs) { auto recordedModTime = inputPair.second.previousModTime; if (recordedModTime == llvm::sys::TimeValue::MaxTime()) continue; const char *input = inputPair.first->getValue(); llvm::sys::fs::file_status inputStatus; if (auto statError = llvm::sys::fs::status(input, inputStatus)) { diags.diagnose(SourceLoc(), diag::warn_cannot_stat_input, llvm::sys::path::filename(input), statError.message()); continue; } if (recordedModTime != inputStatus.getLastModificationTime()) { diags.diagnose(SourceLoc(), diag::error_input_changed_during_build, llvm::sys::path::filename(input)); } } }
/// Try to read a file list file. /// /// Returns false on error. static bool readFileList(DiagnosticEngine &diags, std::vector<std::string> &inputFiles, const llvm::opt::Arg *filelistPath, const llvm::opt::Arg *primaryFileArg = nullptr, unsigned *primaryFileIndex = nullptr) { assert((primaryFileArg == nullptr) || (primaryFileIndex != nullptr) && "did not provide argument for primary file index"); llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer = llvm::MemoryBuffer::getFile(filelistPath->getValue()); if (!buffer) { diags.diagnose(SourceLoc(), diag::cannot_open_file, filelistPath->getValue(), buffer.getError().message()); return false; } bool foundPrimaryFile = false; if (primaryFileIndex) *primaryFileIndex = 0; for (StringRef line : make_range(llvm::line_iterator(*buffer.get()), {})) { inputFiles.push_back(line); if (foundPrimaryFile || primaryFileArg == nullptr) continue; if (line == primaryFileArg->getValue()) foundPrimaryFile = true; else ++*primaryFileIndex; } if (primaryFileArg && !foundPrimaryFile) { diags.diagnose(SourceLoc(), diag::error_primary_file_not_found, primaryFileArg->getValue(), filelistPath->getValue()); return false; } return true; }
/// Emits a Make-style dependencies file. static bool emitMakeDependencies(DiagnosticEngine &diags, DependencyTracker &depTracker, const FrontendOptions &opts) { std::error_code EC; llvm::raw_fd_ostream out(opts.DependenciesFilePath, EC, llvm::sys::fs::F_None); if (out.has_error() || EC) { diags.diagnose(SourceLoc(), diag::error_opening_output, opts.DependenciesFilePath, EC.message()); out.clear_error(); return true; } // Declare a helper for escaping file names for use in Makefiles. llvm::SmallString<256> pathBuf; auto escape = [&](StringRef raw) -> StringRef { pathBuf.clear(); static const char badChars[] = " $#:\n"; size_t prev = 0; for (auto index = raw.find_first_of(badChars); index != StringRef::npos; index = raw.find_first_of(badChars, index+1)) { pathBuf.append(raw.slice(prev, index)); if (raw[index] == '$') pathBuf.push_back('$'); else pathBuf.push_back('\\'); prev = index; } pathBuf.append(raw.substr(prev)); return pathBuf; }; // FIXME: Xcode can't currently handle multiple targets in a single // dependency line. opts.forAllOutputPaths([&](StringRef targetName) { out << escape(targetName) << " :"; // First include all other files in the module. Make-style dependencies // need to be conservative! for (StringRef path : opts.InputFilenames) out << ' ' << escape(path); // Then print dependencies we've picked up during compilation. for (StringRef path : depTracker.getDependencies()) out << ' ' << escape(path); out << '\n'; }); return false; }
static bool recordSourceFileUnit(SourceFile *primarySourceFile, StringRef indexUnitToken, StringRef indexStorePath, bool indexSystemModules, bool isDebugCompilation, StringRef targetTriple, ArrayRef<const clang::FileEntry *> fileDependencies, const clang::CompilerInstance &clangCI, DiagnosticEngine &diags) { auto &fileMgr = clangCI.getFileManager(); auto *module = primarySourceFile->getParentModule(); bool isSystem = module->isSystemModule(); auto *mainFile = fileMgr.getFile(primarySourceFile->getFilename()); // FIXME: Get real values for the following. StringRef swiftVersion; StringRef sysrootPath = clangCI.getHeaderSearchOpts().Sysroot; IndexUnitWriter unitWriter(fileMgr, indexStorePath, "swift", swiftVersion, indexUnitToken, module->getNameStr(), mainFile, isSystem, /*isModuleUnit=*/false, isDebugCompilation, targetTriple, sysrootPath, getModuleInfoFromOpaqueModule); // Module dependencies. ModuleDecl::ImportFilter importFilter; importFilter |= ModuleDecl::ImportFilterKind::Public; importFilter |= ModuleDecl::ImportFilterKind::Private; importFilter |= ModuleDecl::ImportFilterKind::ImplementationOnly; SmallVector<ModuleDecl::ImportedModule, 8> imports; primarySourceFile->getImportedModules(imports, importFilter); StringScratchSpace moduleNameScratch; addModuleDependencies(imports, indexStorePath, indexSystemModules, targetTriple, clangCI, diags, unitWriter, moduleNameScratch); // File dependencies. for (auto *F : fileDependencies) unitWriter.addFileDependency(F, /*FIXME:isSystem=*/false, /*Module=*/nullptr); recordSourceFile(primarySourceFile, indexStorePath, diags, [&](StringRef recordFile, StringRef filename) { unitWriter.addRecordFile(recordFile, fileMgr.getFile(filename), module->isSystemModule(), /*Module=*/nullptr); }); std::string error; if (unitWriter.write(error)) { diags.diagnose(SourceLoc(), diag::error_write_index_unit, error); return true; } return false; }
Optional<std::vector<std::string>> ArgsToFrontendOutputsConverter::readOutputFileList(const StringRef filelistPath, DiagnosticEngine &diags) { llvm::ErrorOr<std::unique_ptr<llvm::MemoryBuffer>> buffer = llvm::MemoryBuffer::getFile(filelistPath); if (!buffer) { diags.diagnose(SourceLoc(), diag::cannot_open_file, filelistPath, buffer.getError().message()); return None; } std::vector<std::string> outputFiles; for (StringRef line : make_range(llvm::line_iterator(*buffer.get()), {})) { outputFiles.push_back(line.str()); } return outputFiles; }
int getTokensFromFile(const StringRef InputFilename, LangOptions &LangOpts, SourceManager &SourceMgr, DiagnosticEngine &Diags, std::vector<std::pair<RC<syntax::TokenSyntax>, syntax::AbsolutePosition>> &Tokens) { auto Buffer = llvm::MemoryBuffer::getFile(InputFilename); if (!Buffer) { Diags.diagnose(SourceLoc(), diag::cannot_open_file, InputFilename, Buffer.getError().message()); return EXIT_FAILURE; } auto BufferID = SourceMgr.addNewSourceBuffer(std::move(Buffer.get())); return getTokensFromFile(BufferID, LangOpts, SourceMgr, Diags, Tokens); }
static bool writeAllSourcesFile(DiagnosticEngine &diags, StringRef path, ArrayRef<InputPair> inputFiles) { std::error_code error; llvm::raw_fd_ostream out(path, error, llvm::sys::fs::F_None); if (out.has_error()) { out.clear_error(); diags.diagnose(SourceLoc(), diag::error_unable_to_make_temporary_file, error.message()); return false; } for (auto inputPair : inputFiles) { if (!types::isPartOfSwiftCompilation(inputPair.first)) continue; out << inputPair.second->getValue() << "\n"; } return true; }
Optional<OutputFilesComputer> OutputFilesComputer::create(const llvm::opt::ArgList &args, DiagnosticEngine &diags, const FrontendInputsAndOutputs &inputsAndOutputs) { Optional<std::vector<std::string>> outputArguments = getOutputFilenamesFromCommandLineOrFilelist(args, diags); if (!outputArguments) return None; const StringRef outputDirectoryArgument = outputArguments->size() == 1 && llvm::sys::fs::is_directory(outputArguments->front()) ? StringRef(outputArguments->front()) : StringRef(); ArrayRef<std::string> outputFileArguments = outputDirectoryArgument.empty() ? ArrayRef<std::string>(*outputArguments) : ArrayRef<std::string>(); const StringRef firstInput = inputsAndOutputs.hasSingleInput() ? StringRef(inputsAndOutputs.getFilenameOfFirstInput()) : StringRef(); const FrontendOptions::ActionType requestedAction = ArgsToFrontendOptionsConverter::determineRequestedAction(args); if (!outputFileArguments.empty() && outputFileArguments.size() != inputsAndOutputs.countOfInputsProducingMainOutputs()) { diags.diagnose( SourceLoc(), diag::error_if_any_output_files_are_specified_they_all_must_be); return None; } const file_types::ID outputType = FrontendOptions::formatForPrincipalOutputFileForAction(requestedAction); return OutputFilesComputer( diags, inputsAndOutputs, std::move(outputFileArguments), outputDirectoryArgument, firstInput, requestedAction, args.getLastArg(options::OPT_module_name), file_types::getExtension(outputType), FrontendOptions::doesActionProduceTextualOutput(requestedAction)); }
static bool writeFilelistIfNecessary(const Job *job, DiagnosticEngine &diags) { FilelistInfo filelistInfo = job->getFilelistInfo(); if (filelistInfo.path.empty()) return true; std::error_code error; llvm::raw_fd_ostream out(filelistInfo.path, error, llvm::sys::fs::F_None); if (out.has_error()) { out.clear_error(); diags.diagnose(SourceLoc(), diag::error_unable_to_make_temporary_file, error.message()); return false; } if (filelistInfo.whichFiles == FilelistInfo::Input) { // FIXME: Duplicated from ToolChains.cpp. for (const Job *input : job->getInputs()) { const CommandOutput &outputInfo = input->getOutput(); if (outputInfo.getPrimaryOutputType() == filelistInfo.type) { for (auto &output : outputInfo.getPrimaryOutputFilenames()) out << output << "\n"; } else { auto &output = outputInfo.getAnyOutputForType(filelistInfo.type); if (!output.empty()) out << output << "\n"; } } } else { const CommandOutput &outputInfo = job->getOutput(); assert(outputInfo.getPrimaryOutputType() == filelistInfo.type); for (auto &output : outputInfo.getPrimaryOutputFilenames()) out << output << "\n"; } return true; }
static bool ParseFrontendArgs(FrontendOptions &Opts, ArgList &Args, DiagnosticEngine &Diags) { using namespace options; if (const Arg *A = Args.getLastArg(OPT_debug_crash_Group)) { Option Opt = A->getOption(); if (Opt.matches(OPT_debug_assert_immediately)) { debugFailWithAssertion(); } else if (Opt.matches(OPT_debug_crash_immediately)) { debugFailWithCrash(); } else if (Opt.matches(OPT_debug_assert_after_parse)) { // Set in FrontendOptions Opts.CrashMode = FrontendOptions::DebugCrashMode::AssertAfterParse; } else if (Opt.matches(OPT_debug_crash_after_parse)) { // Set in FrontendOptions Opts.CrashMode = FrontendOptions::DebugCrashMode::CrashAfterParse; } else { llvm_unreachable("Unknown debug_crash_Group option!"); } } if (const Arg *A = Args.getLastArg(OPT_dump_api_path)) { Opts.DumpAPIPath = A->getValue(); } Opts.EmitVerboseSIL |= Args.hasArg(OPT_emit_verbose_sil); Opts.EmitSortedSIL |= Args.hasArg(OPT_emit_sorted_sil); Opts.DelayedFunctionBodyParsing |= Args.hasArg(OPT_delayed_function_body_parsing); Opts.EnableTesting |= Args.hasArg(OPT_enable_testing); Opts.EnableResilience |= Args.hasArg(OPT_enable_resilience); Opts.PrintStats |= Args.hasArg(OPT_print_stats); Opts.PrintClangStats |= Args.hasArg(OPT_print_clang_stats); Opts.DebugTimeFunctionBodies |= Args.hasArg(OPT_debug_time_function_bodies); Opts.DebugTimeCompilation |= Args.hasArg(OPT_debug_time_compilation); Opts.PlaygroundTransform |= Args.hasArg(OPT_playground); if (Args.hasArg(OPT_disable_playground_transform)) Opts.PlaygroundTransform = false; Opts.PlaygroundHighPerformance |= Args.hasArg(OPT_playground_high_performance); if (const Arg *A = Args.getLastArg(OPT_help, OPT_help_hidden)) { if (A->getOption().matches(OPT_help)) { Opts.PrintHelp = true; } else if (A->getOption().matches(OPT_help_hidden)) { Opts.PrintHelpHidden = true; } else { llvm_unreachable("Unknown help option parsed"); } } if (const Arg *A = Args.getLastArg(OPT_filelist)) { const Arg *primaryFileArg = Args.getLastArg(OPT_primary_file); auto primaryFileIndex = readFileList(Opts.InputFilenames, A, primaryFileArg); if (primaryFileArg) Opts.PrimaryInput = SelectedInput(primaryFileIndex); assert(!Args.hasArg(OPT_INPUT) && "mixing -filelist with inputs"); } else { for (const Arg *A : make_range(Args.filtered_begin(OPT_INPUT, OPT_primary_file), Args.filtered_end())) { if (A->getOption().matches(OPT_INPUT)) { Opts.InputFilenames.push_back(A->getValue()); } else if (A->getOption().matches(OPT_primary_file)) { Opts.PrimaryInput = SelectedInput(Opts.InputFilenames.size()); Opts.InputFilenames.push_back(A->getValue()); } else { llvm_unreachable("Unknown input-related argument!"); } } } Opts.ParseStdlib |= Args.hasArg(OPT_parse_stdlib); // Determine what the user has asked the frontend to do. FrontendOptions::ActionType &Action = Opts.RequestedAction; if (const Arg *A = Args.getLastArg(OPT_modes_Group)) { Option Opt = A->getOption(); if (Opt.matches(OPT_emit_object)) { Action = FrontendOptions::EmitObject; } else if (Opt.matches(OPT_emit_assembly)) { Action = FrontendOptions::EmitAssembly; } else if (Opt.matches(OPT_emit_ir)) { Action = FrontendOptions::EmitIR; } else if (Opt.matches(OPT_emit_bc)) { Action = FrontendOptions::EmitBC; } else if (Opt.matches(OPT_emit_sil)) { Action = FrontendOptions::EmitSIL; } else if (Opt.matches(OPT_emit_silgen)) { Action = FrontendOptions::EmitSILGen; } else if (Opt.matches(OPT_emit_sib)) { Action = FrontendOptions::EmitSIB; } else if (Opt.matches(OPT_emit_sibgen)) { Action = FrontendOptions::EmitSIBGen; } else if (Opt.matches(OPT_parse)) { Action = FrontendOptions::Parse; } else if (Opt.matches(OPT_dump_parse)) { Action = FrontendOptions::DumpParse; } else if (Opt.matches(OPT_dump_ast)) { Action = FrontendOptions::DumpAST; } else if (Opt.matches(OPT_dump_type_refinement_contexts)) { Action = FrontendOptions::DumpTypeRefinementContexts; } else if (Opt.matches(OPT_dump_interface_hash)) { Action = FrontendOptions::DumpInterfaceHash; } else if (Opt.matches(OPT_print_ast)) { Action = FrontendOptions::PrintAST; } else if (Opt.matches(OPT_repl) || Opt.matches(OPT_deprecated_integrated_repl)) { Action = FrontendOptions::REPL; } else if (Opt.matches(OPT_interpret)) { Action = FrontendOptions::Immediate; } else { llvm_unreachable("Unhandled mode option"); } } else { // We don't have a mode, so determine a default. if (Args.hasArg(OPT_emit_module, OPT_emit_module_path)) { // We've been told to emit a module, but have no other mode indicators. // As a result, put the frontend into EmitModuleOnly mode. // (Setting up module output will be handled below.) Action = FrontendOptions::EmitModuleOnly; } } if (Opts.RequestedAction == FrontendOptions::Immediate && Opts.PrimaryInput.hasValue()) { Diags.diagnose(SourceLoc(), diag::error_immediate_mode_primary_file); return true; } bool TreatAsSIL = Args.hasArg(OPT_parse_sil); if (!TreatAsSIL && Opts.InputFilenames.size() == 1) { // If we have exactly one input filename, and its extension is "sil", // treat the input as SIL. StringRef Input(Opts.InputFilenames[0]); TreatAsSIL = llvm::sys::path::extension(Input).endswith(SIL_EXTENSION); } else if (Opts.PrimaryInput.hasValue() && Opts.PrimaryInput->isFilename()) { // If we have a primary input and it's a filename with extension "sil", // treat the input as SIL. StringRef Input(Opts.InputFilenames[Opts.PrimaryInput->Index]); TreatAsSIL = llvm::sys::path::extension(Input).endswith(SIL_EXTENSION); } // If we have exactly one input filename, and its extension is "bc" or "ll", // treat the input as LLVM_IR. bool TreatAsLLVM = false; if (Opts.InputFilenames.size() == 1) { StringRef Input(Opts.InputFilenames[0]); TreatAsLLVM = llvm::sys::path::extension(Input).endswith(LLVM_BC_EXTENSION) || llvm::sys::path::extension(Input).endswith(LLVM_IR_EXTENSION); } if (Opts.RequestedAction == FrontendOptions::REPL) { if (!Opts.InputFilenames.empty()) { Diags.diagnose(SourceLoc(), diag::error_repl_requires_no_input_files); return true; } } else if (TreatAsSIL && Opts.PrimaryInput.hasValue()) { // If we have the SIL as our primary input, we can waive the one file // requirement as long as all the other inputs are SIBs. if (Opts.PrimaryInput.hasValue()) { for (unsigned i = 0, e = Opts.InputFilenames.size(); i != e; ++i) { if (i == Opts.PrimaryInput->Index) continue; StringRef File(Opts.InputFilenames[i]); if (!llvm::sys::path::extension(File).endswith(SIB_EXTENSION)) { Diags.diagnose(SourceLoc(), diag::error_mode_requires_one_sil_multi_sib); return true; } } } } else if (TreatAsSIL) { if (Opts.InputFilenames.size() != 1) { Diags.diagnose(SourceLoc(), diag::error_mode_requires_one_input_file); return true; } } else if (Opts.RequestedAction != FrontendOptions::NoneAction) { if (Opts.InputFilenames.empty()) { Diags.diagnose(SourceLoc(), diag::error_mode_requires_an_input_file); return true; } } if (Opts.RequestedAction == FrontendOptions::Immediate) { assert(!Opts.InputFilenames.empty()); Opts.ImmediateArgv.push_back(Opts.InputFilenames[0]); // argv[0] if (const Arg *A = Args.getLastArg(OPT__DASH_DASH)) { for (unsigned i = 0, e = A->getNumValues(); i != e; ++i) { Opts.ImmediateArgv.push_back(A->getValue(i)); } } } if (TreatAsSIL) Opts.InputKind = InputFileKind::IFK_SIL; else if (TreatAsLLVM) Opts.InputKind = InputFileKind::IFK_LLVM_IR; else if (Args.hasArg(OPT_parse_as_library)) Opts.InputKind = InputFileKind::IFK_Swift_Library; else if (Action == FrontendOptions::REPL) Opts.InputKind = InputFileKind::IFK_Swift_REPL; else Opts.InputKind = InputFileKind::IFK_Swift; if (const Arg *A = Args.getLastArg(OPT_output_filelist)) { readFileList(Opts.OutputFilenames, A); assert(!Args.hasArg(OPT_o) && "don't use -o with -output-filelist"); } else { Opts.OutputFilenames = Args.getAllArgValues(OPT_o); } bool UserSpecifiedModuleName = false; { const Arg *A = Args.getLastArg(OPT_module_name); StringRef ModuleName = Opts.ModuleName; if (A) { ModuleName = A->getValue(); UserSpecifiedModuleName = true; } else if (ModuleName.empty()) { // The user did not specify a module name, so determine a default fallback // based on other options. // Note: this code path will only be taken when running the frontend // directly; the driver should always pass -module-name when invoking the // frontend. if (Opts.RequestedAction == FrontendOptions::REPL) { // Default to a module named "REPL" if we're in REPL mode. ModuleName = "REPL"; } else if (!Opts.InputFilenames.empty()) { StringRef OutputFilename = Opts.getSingleOutputFilename(); if (OutputFilename.empty() || OutputFilename == "-" || llvm::sys::fs::is_directory(OutputFilename)) { ModuleName = Opts.InputFilenames[0]; } else { ModuleName = OutputFilename; } ModuleName = llvm::sys::path::stem(ModuleName); } } if (!Lexer::isIdentifier(ModuleName) || (ModuleName == STDLIB_NAME && !Opts.ParseStdlib)) { if (!Opts.actionHasOutput() || (Opts.InputKind == InputFileKind::IFK_Swift && Opts.InputFilenames.size() == 1)) { ModuleName = "main"; } else { auto DID = (ModuleName == STDLIB_NAME) ? diag::error_stdlib_module_name : diag::error_bad_module_name; Diags.diagnose(SourceLoc(), DID, ModuleName, A == nullptr); ModuleName = "__bad__"; } } Opts.ModuleName = ModuleName; } if (Opts.OutputFilenames.empty() || llvm::sys::fs::is_directory(Opts.getSingleOutputFilename())) { // No output filename was specified, or an output directory was specified. // Determine the correct output filename. // Note: this should typically only be used when invoking the frontend // directly, as the driver will always pass -o with an appropriate filename // if output is required for the requested action. StringRef Suffix; switch (Opts.RequestedAction) { case FrontendOptions::NoneAction: break; case FrontendOptions::Parse: case FrontendOptions::DumpParse: case FrontendOptions::DumpInterfaceHash: case FrontendOptions::DumpAST: case FrontendOptions::PrintAST: case FrontendOptions::DumpTypeRefinementContexts: // Textual modes. Opts.setSingleOutputFilename("-"); break; case FrontendOptions::EmitSILGen: case FrontendOptions::EmitSIL: { if (Opts.OutputFilenames.empty()) Opts.setSingleOutputFilename("-"); else Suffix = SIL_EXTENSION; break; } case FrontendOptions::EmitSIBGen: case FrontendOptions::EmitSIB: Suffix = SIB_EXTENSION; break; case FrontendOptions::EmitModuleOnly: Suffix = SERIALIZED_MODULE_EXTENSION; break; case FrontendOptions::Immediate: case FrontendOptions::REPL: // These modes have no frontend-generated output. Opts.OutputFilenames.clear(); break; case FrontendOptions::EmitAssembly: { if (Opts.OutputFilenames.empty()) Opts.setSingleOutputFilename("-"); else Suffix = "s"; break; } case FrontendOptions::EmitIR: { if (Opts.OutputFilenames.empty()) Opts.setSingleOutputFilename("-"); else Suffix = "ll"; break; } case FrontendOptions::EmitBC: { Suffix = "bc"; break; } case FrontendOptions::EmitObject: Suffix = "o"; break; } if (!Suffix.empty()) { // We need to deduce a file name. // First, if we're reading from stdin and we don't have a directory, // output to stdout. if (Opts.InputFilenames.size() == 1 && Opts.InputFilenames[0] == "-" && Opts.OutputFilenames.empty()) Opts.setSingleOutputFilename("-"); else { // We have a suffix, so determine an appropriate name. llvm::SmallString<128> Path(Opts.getSingleOutputFilename()); StringRef BaseName; if (Opts.PrimaryInput.hasValue() && Opts.PrimaryInput->isFilename()) { unsigned Index = Opts.PrimaryInput->Index; BaseName = llvm::sys::path::stem(Opts.InputFilenames[Index]); } else if (!UserSpecifiedModuleName && Opts.InputFilenames.size() == 1) { BaseName = llvm::sys::path::stem(Opts.InputFilenames[0]); } else { BaseName = Opts.ModuleName; } llvm::sys::path::append(Path, BaseName); llvm::sys::path::replace_extension(Path, Suffix); Opts.setSingleOutputFilename(Path.str()); } } if (Opts.OutputFilenames.empty()) { if (Opts.RequestedAction != FrontendOptions::REPL && Opts.RequestedAction != FrontendOptions::Immediate && Opts.RequestedAction != FrontendOptions::NoneAction) { Diags.diagnose(SourceLoc(), diag::error_no_output_filename_specified); return true; } } else if (Opts.getSingleOutputFilename() != "-" && llvm::sys::fs::is_directory(Opts.getSingleOutputFilename())) { Diags.diagnose(SourceLoc(), diag::error_implicit_output_file_is_directory, Opts.getSingleOutputFilename()); return true; } } auto determineOutputFilename = [&](std::string &output, OptSpecifier optWithoutPath, OptSpecifier optWithPath, const char *extension, bool useMainOutput) { if (const Arg *A = Args.getLastArg(optWithPath)) { Args.ClaimAllArgs(optWithoutPath); output = A->getValue(); return; } if (!Args.hasArg(optWithoutPath)) return; if (useMainOutput && !Opts.OutputFilenames.empty()) { output = Opts.getSingleOutputFilename(); return; } if (!output.empty()) return; StringRef OriginalPath; if (!Opts.OutputFilenames.empty() && Opts.getSingleOutputFilename() != "-") // Put the serialized diagnostics file next to the output file. OriginalPath = Opts.getSingleOutputFilename(); else if (Opts.PrimaryInput.hasValue() && Opts.PrimaryInput->isFilename()) // We have a primary input, so use that as the basis for the name of the // serialized diagnostics file. OriginalPath = llvm::sys::path::filename( Opts.InputFilenames[Opts.PrimaryInput->Index]); else // We don't have any better indication of name, so fall back on the // module name. OriginalPath = Opts.ModuleName; llvm::SmallString<128> Path(OriginalPath); llvm::sys::path::replace_extension(Path, extension); output = Path.str(); }; determineOutputFilename(Opts.DependenciesFilePath, OPT_emit_dependencies, OPT_emit_dependencies_path, "d", false); determineOutputFilename(Opts.ReferenceDependenciesFilePath, OPT_emit_reference_dependencies, OPT_emit_reference_dependencies_path, "swiftdeps", false); determineOutputFilename(Opts.SerializedDiagnosticsPath, OPT_serialize_diagnostics, OPT_serialize_diagnostics_path, "dia", false); determineOutputFilename(Opts.ObjCHeaderOutputPath, OPT_emit_objc_header, OPT_emit_objc_header_path, "h", false); if (const Arg *A = Args.getLastArg(OPT_emit_fixits_path)) { Opts.FixitsOutputPath = A->getValue(); } bool IsSIB = Opts.RequestedAction == FrontendOptions::EmitSIB || Opts.RequestedAction == FrontendOptions::EmitSIBGen; bool canUseMainOutputForModule = Opts.RequestedAction == FrontendOptions::EmitModuleOnly || IsSIB; auto ext = IsSIB ? SIB_EXTENSION : SERIALIZED_MODULE_EXTENSION; auto sibOpt = Opts.RequestedAction == FrontendOptions::EmitSIB ? OPT_emit_sib : OPT_emit_sibgen; determineOutputFilename(Opts.ModuleOutputPath, IsSIB ? sibOpt : OPT_emit_module, OPT_emit_module_path, ext, canUseMainOutputForModule); determineOutputFilename(Opts.ModuleDocOutputPath, OPT_emit_module_doc, OPT_emit_module_doc_path, SERIALIZED_MODULE_DOC_EXTENSION, false); if (!Opts.DependenciesFilePath.empty()) { switch (Opts.RequestedAction) { case FrontendOptions::NoneAction: case FrontendOptions::DumpParse: case FrontendOptions::DumpInterfaceHash: case FrontendOptions::DumpAST: case FrontendOptions::PrintAST: case FrontendOptions::DumpTypeRefinementContexts: case FrontendOptions::Immediate: case FrontendOptions::REPL: Diags.diagnose(SourceLoc(), diag::error_mode_cannot_emit_dependencies); return true; case FrontendOptions::Parse: case FrontendOptions::EmitModuleOnly: case FrontendOptions::EmitSILGen: case FrontendOptions::EmitSIL: case FrontendOptions::EmitSIBGen: case FrontendOptions::EmitSIB: case FrontendOptions::EmitIR: case FrontendOptions::EmitBC: case FrontendOptions::EmitAssembly: case FrontendOptions::EmitObject: break; } } if (!Opts.ObjCHeaderOutputPath.empty()) { switch (Opts.RequestedAction) { case FrontendOptions::NoneAction: case FrontendOptions::DumpParse: case FrontendOptions::DumpInterfaceHash: case FrontendOptions::DumpAST: case FrontendOptions::PrintAST: case FrontendOptions::DumpTypeRefinementContexts: case FrontendOptions::Immediate: case FrontendOptions::REPL: Diags.diagnose(SourceLoc(), diag::error_mode_cannot_emit_header); return true; case FrontendOptions::Parse: case FrontendOptions::EmitModuleOnly: case FrontendOptions::EmitSILGen: case FrontendOptions::EmitSIL: case FrontendOptions::EmitSIBGen: case FrontendOptions::EmitSIB: case FrontendOptions::EmitIR: case FrontendOptions::EmitBC: case FrontendOptions::EmitAssembly: case FrontendOptions::EmitObject: break; } } if (!Opts.ModuleOutputPath.empty() || !Opts.ModuleDocOutputPath.empty()) { switch (Opts.RequestedAction) { case FrontendOptions::NoneAction: case FrontendOptions::Parse: case FrontendOptions::DumpParse: case FrontendOptions::DumpInterfaceHash: case FrontendOptions::DumpAST: case FrontendOptions::PrintAST: case FrontendOptions::DumpTypeRefinementContexts: case FrontendOptions::EmitSILGen: case FrontendOptions::Immediate: case FrontendOptions::REPL: if (!Opts.ModuleOutputPath.empty()) Diags.diagnose(SourceLoc(), diag::error_mode_cannot_emit_module); else Diags.diagnose(SourceLoc(), diag::error_mode_cannot_emit_module_doc); return true; case FrontendOptions::EmitModuleOnly: case FrontendOptions::EmitSIL: case FrontendOptions::EmitSIBGen: case FrontendOptions::EmitSIB: case FrontendOptions::EmitIR: case FrontendOptions::EmitBC: case FrontendOptions::EmitAssembly: case FrontendOptions::EmitObject: break; } } if (const Arg *A = Args.getLastArg(OPT_module_link_name)) { Opts.ModuleLinkName = A->getValue(); } Opts.AlwaysSerializeDebuggingOptions |= Args.hasArg(OPT_serialize_debugging_options); Opts.EnableSourceImport |= Args.hasArg(OPT_enable_source_import); Opts.ImportUnderlyingModule |= Args.hasArg(OPT_import_underlying_module); Opts.SILSerializeAll |= Args.hasArg(OPT_sil_serialize_all); if (const Arg *A = Args.getLastArg(OPT_import_objc_header)) { Opts.ImplicitObjCHeaderPath = A->getValue(); Opts.SerializeBridgingHeader |= !Opts.PrimaryInput && !Opts.ModuleOutputPath.empty(); } for (const Arg *A : make_range(Args.filtered_begin(OPT_import_module), Args.filtered_end())) { Opts.ImplicitImportModuleNames.push_back(A->getValue()); } for (const Arg *A : make_range(Args.filtered_begin(OPT_Xllvm), Args.filtered_end())) { Opts.LLVMArgs.push_back(A->getValue()); } return false; }
bool CompilerInvocation::parseArgs(ArrayRef<const char *> Args, DiagnosticEngine &Diags, StringRef workingDirectory) { using namespace options; if (Args.empty()) return false; // Parse frontend command line options using Swift's option table. unsigned MissingIndex; unsigned MissingCount; std::unique_ptr<llvm::opt::OptTable> Table = createSwiftOptTable(); llvm::opt::InputArgList ParsedArgs = Table->ParseArgs(Args, MissingIndex, MissingCount, FrontendOption); if (MissingCount) { Diags.diagnose(SourceLoc(), diag::error_missing_arg_value, ParsedArgs.getArgString(MissingIndex), MissingCount); return true; } if (ParsedArgs.hasArg(OPT_UNKNOWN)) { for (const Arg *A : make_range(ParsedArgs.filtered_begin(OPT_UNKNOWN), ParsedArgs.filtered_end())) { Diags.diagnose(SourceLoc(), diag::error_unknown_arg, A->getAsString(ParsedArgs)); } return true; } if (ParseFrontendArgs(FrontendOpts, ParsedArgs, Diags)) { return true; } if (ParseLangArgs(LangOpts, ParsedArgs, Diags, FrontendOpts.actionIsImmediate())) { return true; } if (ParseClangImporterArgs(ClangImporterOpts, ParsedArgs, Diags, workingDirectory)) { return true; } if (ParseSearchPathArgs(SearchPathOpts, ParsedArgs, Diags, workingDirectory)) { return true; } if (ParseSILArgs(SILOpts, ParsedArgs, IRGenOpts, FrontendOpts, Diags)) { return true; } if (ParseIRGenArgs(IRGenOpts, ParsedArgs, Diags, FrontendOpts, getSDKPath(), SearchPathOpts.RuntimeResourcePath)) { return true; } if (ParseDiagnosticArgs(DiagnosticOpts, ParsedArgs, Diags)) { return true; } updateRuntimeLibraryPath(SearchPathOpts, LangOpts.Target); return false; }
static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args, DiagnosticEngine &Diags, const FrontendOptions &FrontendOpts, StringRef SDKPath, StringRef ResourceDir) { using namespace options; if (const Arg *A = Args.getLastArg(OPT_g_Group)) { if (A->getOption().matches(OPT_g)) Opts.DebugInfoKind = IRGenDebugInfoKind::Normal; else if (A->getOption().matches(options::OPT_gline_tables_only)) Opts.DebugInfoKind = IRGenDebugInfoKind::LineTables; else assert(A->getOption().matches(options::OPT_gnone) && "unknown -g<kind> option"); if (Opts.DebugInfoKind == IRGenDebugInfoKind::Normal) { ArgStringList RenderedArgs; for (auto A : Args) A->render(Args, RenderedArgs); CompilerInvocation::buildDWARFDebugFlags(Opts.DWARFDebugFlags, RenderedArgs, SDKPath, ResourceDir); // TODO: Should we support -fdebug-compilation-dir? llvm::SmallString<256> cwd; llvm::sys::fs::current_path(cwd); Opts.DebugCompilationDir = cwd.str(); } } for (const Arg *A : make_range(Args.filtered_begin(OPT_l, OPT_framework), Args.filtered_end())) { LibraryKind Kind; if (A->getOption().matches(OPT_l)) { Kind = LibraryKind::Library; } else if (A->getOption().matches(OPT_framework)) { Kind = LibraryKind::Framework; } else { llvm_unreachable("Unknown LinkLibrary option kind"); } Opts.LinkLibraries.push_back(LinkLibrary(A->getValue(), Kind)); } if (auto valueNames = Args.getLastArg(OPT_disable_llvm_value_names, OPT_enable_llvm_value_names)) { Opts.HasValueNamesSetting = true; Opts.ValueNames = valueNames->getOption().matches(OPT_enable_llvm_value_names); } Opts.DisableLLVMOptzns |= Args.hasArg(OPT_disable_llvm_optzns); Opts.DisableLLVMARCOpts |= Args.hasArg(OPT_disable_llvm_arc_opts); Opts.DisableLLVMSLPVectorizer |= Args.hasArg(OPT_disable_llvm_slp_vectorizer); if (Args.hasArg(OPT_disable_llvm_verify)) Opts.Verify = false; Opts.EmitStackPromotionChecks |= Args.hasArg(OPT_stack_promotion_checks); if (const Arg *A = Args.getLastArg(OPT_stack_promotion_limit)) { unsigned limit; if (StringRef(A->getValue()).getAsInteger(10, limit)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.StackPromotionSizeLimit = limit; } if (Args.hasArg(OPT_autolink_force_load)) Opts.ForceLoadSymbolName = Args.getLastArgValue(OPT_module_link_name); // TODO: investigate whether these should be removed, in favor of definitions // in other classes. if (FrontendOpts.PrimaryInput && FrontendOpts.PrimaryInput->isFilename()) { unsigned Index = FrontendOpts.PrimaryInput->Index; Opts.MainInputFilename = FrontendOpts.InputFilenames[Index]; } else if (FrontendOpts.InputFilenames.size() == 1) { Opts.MainInputFilename = FrontendOpts.InputFilenames.front(); } Opts.OutputFilenames = FrontendOpts.OutputFilenames; Opts.ModuleName = FrontendOpts.ModuleName; if (Args.hasArg(OPT_use_jit)) Opts.UseJIT = true; for (const Arg *A : make_range(Args.filtered_begin(OPT_verify_type_layout), Args.filtered_end())) { Opts.VerifyTypeLayoutNames.push_back(A->getValue()); } for (const Arg *A : make_range(Args.filtered_begin( OPT_disable_autolink_framework), Args.filtered_end())) { Opts.DisableAutolinkFrameworks.push_back(A->getValue()); } Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate); Opts.PrintInlineTree |= Args.hasArg(OPT_print_llvm_inline_tree); if (Args.hasArg(OPT_embed_bitcode)) Opts.EmbedMode = IRGenEmbedMode::EmbedBitcode; else if (Args.hasArg(OPT_embed_bitcode_marker)) Opts.EmbedMode = IRGenEmbedMode::EmbedMarker; if (Opts.EmbedMode == IRGenEmbedMode::EmbedBitcode) { // Keep track of backend options so we can embed them in a separate data // section and use them when building from the bitcode. This can be removed // when all the backend options are recorded in the IR. for (ArgList::const_iterator A = Args.begin(), AE = Args.end(); A != AE; ++ A) { // Do not encode output and input. if ((*A)->getOption().getID() == options::OPT_o || (*A)->getOption().getID() == options::OPT_INPUT || (*A)->getOption().getID() == options::OPT_primary_file || (*A)->getOption().getID() == options::OPT_embed_bitcode) continue; ArgStringList ASL; (*A)->render(Args, ASL); for (ArgStringList::iterator it = ASL.begin(), ie = ASL.end(); it != ie; ++ it) { StringRef ArgStr(*it); Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end()); // using \00 to terminate to avoid problem decoding. Opts.CmdArgs.push_back('\0'); } } } if (Args.hasArg(OPT_enable_reflection_metadata)) { Opts.StripReflectionMetadata = false; Opts.StripReflectionNames = false; } if (Args.hasArg(OPT_strip_reflection_names)) { Opts.StripReflectionNames = true; } if (Args.hasArg(OPT_strip_reflection_metadata)) { Opts.StripReflectionMetadata = true; Opts.StripReflectionNames = true; } return false; }
bool DiagnosticInfos::process(DiagnosticEngine& pEngine) const { Diagnostic info(pEngine); unsigned int ID = info.getID(); // we are not implement LineInfo, so keep pIsLoC false. const DiagStaticInfo* static_info = getDiagInfo(ID); DiagnosticEngine::Severity severity = static_info->Severity; switch (ID) { case diag::multiple_definitions: { if (m_Config.options().isMulDefs()) { severity = DiagnosticEngine::Ignore; } break; } case diag::undefined_reference: case diag::undefined_reference_text: { // we have not implement --unresolved-symbols=method yet. So far, MCLinker // provides the easier --allow-shlib-undefined and --no-undefined (i.e. // -z defs) switch (m_Config.codeGenType()) { case LinkerConfig::Object: if (m_Config.options().isNoUndefined()) severity = DiagnosticEngine::Error; else severity = DiagnosticEngine::Ignore; break; case LinkerConfig::DynObj: if (m_Config.options().isNoUndefined()) severity = DiagnosticEngine::Error; else severity = DiagnosticEngine::Ignore; break; default: severity = DiagnosticEngine::Error; break; } break; } case diag::debug_print_gc_sections: { if (!m_Config.options().getPrintGCSections()) severity = DiagnosticEngine::Ignore; break; } default: break; } // end of switch // If --fatal-warnings is turned on, then switch warnings and errors to fatal if (m_Config.options().isFatalWarnings()) { if (severity == DiagnosticEngine::Warning || severity == DiagnosticEngine::Error) { severity = DiagnosticEngine::Fatal; } } // finally, report it. pEngine.getPrinter()->handleDiagnostic(severity, info); return true; }
static bool ParseIRGenArgs(IRGenOptions &Opts, ArgList &Args, DiagnosticEngine &Diags, const FrontendOptions &FrontendOpts, const SILOptions &SILOpts, StringRef SDKPath, StringRef ResourceDir, const llvm::Triple &Triple) { using namespace options; if (!SILOpts.SILOutputFileNameForDebugging.empty()) { Opts.DebugInfoKind = IRGenDebugInfoKind::LineTables; } else if (const Arg *A = Args.getLastArg(OPT_g_Group)) { if (A->getOption().matches(OPT_g)) Opts.DebugInfoKind = IRGenDebugInfoKind::Normal; else if (A->getOption().matches(options::OPT_gline_tables_only)) Opts.DebugInfoKind = IRGenDebugInfoKind::LineTables; else if (A->getOption().matches(options::OPT_gdwarf_types)) Opts.DebugInfoKind = IRGenDebugInfoKind::DwarfTypes; else assert(A->getOption().matches(options::OPT_gnone) && "unknown -g<kind> option"); if (Opts.DebugInfoKind > IRGenDebugInfoKind::LineTables) { ArgStringList RenderedArgs; for (auto A : Args) A->render(Args, RenderedArgs); CompilerInvocation::buildDWARFDebugFlags(Opts.DWARFDebugFlags, RenderedArgs, SDKPath, ResourceDir); // TODO: Should we support -fdebug-compilation-dir? llvm::SmallString<256> cwd; llvm::sys::fs::current_path(cwd); Opts.DebugCompilationDir = cwd.str(); } } for (const Arg *A : Args.filtered(OPT_Xcc)) { StringRef Opt = A->getValue(); if (Opt.startswith("-D") || Opt.startswith("-U")) Opts.ClangDefines.push_back(Opt); } for (const Arg *A : Args.filtered(OPT_l, OPT_framework)) { LibraryKind Kind; if (A->getOption().matches(OPT_l)) { Kind = LibraryKind::Library; } else if (A->getOption().matches(OPT_framework)) { Kind = LibraryKind::Framework; } else { llvm_unreachable("Unknown LinkLibrary option kind"); } Opts.LinkLibraries.push_back(LinkLibrary(A->getValue(), Kind)); } if (auto valueNames = Args.getLastArg(OPT_disable_llvm_value_names, OPT_enable_llvm_value_names)) { Opts.HasValueNamesSetting = true; Opts.ValueNames = valueNames->getOption().matches(OPT_enable_llvm_value_names); } Opts.DisableLLVMOptzns |= Args.hasArg(OPT_disable_llvm_optzns); Opts.DisableLLVMARCOpts |= Args.hasArg(OPT_disable_llvm_arc_opts); Opts.DisableLLVMSLPVectorizer |= Args.hasArg(OPT_disable_llvm_slp_vectorizer); if (Args.hasArg(OPT_disable_llvm_verify)) Opts.Verify = false; Opts.EmitStackPromotionChecks |= Args.hasArg(OPT_stack_promotion_checks); if (const Arg *A = Args.getLastArg(OPT_stack_promotion_limit)) { unsigned limit; if (StringRef(A->getValue()).getAsInteger(10, limit)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.StackPromotionSizeLimit = limit; } if (Args.hasArg(OPT_autolink_force_load)) Opts.ForceLoadSymbolName = Args.getLastArgValue(OPT_module_link_name); Opts.ModuleName = FrontendOpts.ModuleName; if (Args.hasArg(OPT_use_jit)) Opts.UseJIT = true; for (const Arg *A : Args.filtered(OPT_verify_type_layout)) { Opts.VerifyTypeLayoutNames.push_back(A->getValue()); } for (const Arg *A : Args.filtered(OPT_disable_autolink_framework)) { Opts.DisableAutolinkFrameworks.push_back(A->getValue()); } Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate); const Arg *ProfileUse = Args.getLastArg(OPT_profile_use); Opts.UseProfile = ProfileUse ? ProfileUse->getValue() : ""; Opts.PrintInlineTree |= Args.hasArg(OPT_print_llvm_inline_tree); Opts.UseSwiftCall = Args.hasArg(OPT_enable_swiftcall); // This is set to true by default. Opts.UseIncrementalLLVMCodeGen &= !Args.hasArg(OPT_disable_incremental_llvm_codegeneration); if (Args.hasArg(OPT_embed_bitcode)) Opts.EmbedMode = IRGenEmbedMode::EmbedBitcode; else if (Args.hasArg(OPT_embed_bitcode_marker)) Opts.EmbedMode = IRGenEmbedMode::EmbedMarker; if (Opts.EmbedMode == IRGenEmbedMode::EmbedBitcode) { // Keep track of backend options so we can embed them in a separate data // section and use them when building from the bitcode. This can be removed // when all the backend options are recorded in the IR. for (const Arg *A : Args) { // Do not encode output and input. if (A->getOption().getID() == options::OPT_o || A->getOption().getID() == options::OPT_INPUT || A->getOption().getID() == options::OPT_primary_file || A->getOption().getID() == options::OPT_embed_bitcode) continue; ArgStringList ASL; A->render(Args, ASL); for (ArgStringList::iterator it = ASL.begin(), ie = ASL.end(); it != ie; ++ it) { StringRef ArgStr(*it); Opts.CmdArgs.insert(Opts.CmdArgs.end(), ArgStr.begin(), ArgStr.end()); // using \00 to terminate to avoid problem decoding. Opts.CmdArgs.push_back('\0'); } } } if (const Arg *A = Args.getLastArg(options::OPT_sanitize_coverage_EQ)) { Opts.SanitizeCoverage = parseSanitizerCoverageArgValue(A, Triple, Diags, Opts.Sanitizers); } else if (Opts.Sanitizers & SanitizerKind::Fuzzer) { // Automatically set coverage flags, unless coverage type was explicitly // requested. Opts.SanitizeCoverage.IndirectCalls = true; Opts.SanitizeCoverage.TraceCmp = true; Opts.SanitizeCoverage.TracePCGuard = true; Opts.SanitizeCoverage.CoverageType = llvm::SanitizerCoverageOptions::SCK_Edge; } if (Args.hasArg(OPT_disable_reflection_metadata)) { Opts.EnableReflectionMetadata = false; Opts.EnableReflectionNames = false; } if (Args.hasArg(OPT_disable_reflection_names)) { Opts.EnableReflectionNames = false; } if (Args.hasArg(OPT_enable_class_resilience)) { Opts.EnableClassResilience = true; } if (Args.hasArg(OPT_enable_resilience_bypass)) { Opts.EnableResilienceBypass = true; } for (const auto &Lib : Args.getAllArgValues(options::OPT_autolink_library)) Opts.LinkLibraries.push_back(LinkLibrary(Lib, LibraryKind::Library)); return false; }
static bool ParseSILArgs(SILOptions &Opts, ArgList &Args, IRGenOptions &IRGenOpts, FrontendOptions &FEOpts, DiagnosticEngine &Diags, const llvm::Triple &Triple, ClangImporterOptions &ClangOpts) { using namespace options; if (const Arg *A = Args.getLastArg(OPT_sil_inline_threshold)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.InlineThreshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (const Arg *A = Args.getLastArg(OPT_sil_inline_caller_benefit_reduction_factor)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.CallerBaseBenefitReductionFactor)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (const Arg *A = Args.getLastArg(OPT_sil_unroll_threshold)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.UnrollThreshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (const Arg *A = Args.getLastArg(OPT_num_threads)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (Args.hasArg(OPT_sil_merge_partial_modules)) Opts.MergePartialModules = true; // Parse the optimization level. // Default to Onone settings if no option is passed. Opts.OptMode = OptimizationMode::NoOptimization; if (const Arg *A = Args.getLastArg(OPT_O_Group)) { if (A->getOption().matches(OPT_Onone)) { // Already set. } else if (A->getOption().matches(OPT_Ounchecked)) { // Turn on optimizations and remove all runtime checks. Opts.OptMode = OptimizationMode::ForSpeed; // Removal of cond_fail (overflow on binary operations). Opts.RemoveRuntimeAsserts = true; Opts.AssertConfig = SILOptions::Unchecked; } else if (A->getOption().matches(OPT_Oplayground)) { // For now -Oplayground is equivalent to -Onone. Opts.OptMode = OptimizationMode::NoOptimization; } else if (A->getOption().matches(OPT_Osize)) { Opts.OptMode = OptimizationMode::ForSize; } else { assert(A->getOption().matches(OPT_O)); Opts.OptMode = OptimizationMode::ForSpeed; } if (Opts.shouldOptimize()) { ClangOpts.Optimization = "-Os"; } } IRGenOpts.OptMode = Opts.OptMode; if (Args.getLastArg(OPT_AssumeSingleThreaded)) { Opts.AssumeSingleThreaded = true; } // Parse the assert configuration identifier. if (const Arg *A = Args.getLastArg(OPT_AssertConfig)) { StringRef Configuration = A->getValue(); if (Configuration == "DisableReplacement") { Opts.AssertConfig = SILOptions::DisableReplacement; } else if (Configuration == "Debug") { Opts.AssertConfig = SILOptions::Debug; } else if (Configuration == "Release") { Opts.AssertConfig = SILOptions::Release; } else if (Configuration == "Unchecked") { Opts.AssertConfig = SILOptions::Unchecked; } else { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } else if (FEOpts.ParseStdlib) { // Disable assertion configuration replacement when we build the standard // library. Opts.AssertConfig = SILOptions::DisableReplacement; } else if (Opts.AssertConfig == SILOptions::Debug) { // Set the assert configuration according to the optimization level if it // has not been set by the -Ounchecked flag. Opts.AssertConfig = (IRGenOpts.shouldOptimize() ? SILOptions::Release : SILOptions::Debug); } // -Ounchecked might also set removal of runtime asserts (cond_fail). Opts.RemoveRuntimeAsserts |= Args.hasArg(OPT_RemoveRuntimeAsserts); Opts.EnableARCOptimizations |= !Args.hasArg(OPT_disable_arc_opts); Opts.DisableSILPerfOptimizations |= Args.hasArg(OPT_disable_sil_perf_optzns); Opts.VerifyAll |= Args.hasArg(OPT_sil_verify_all); Opts.DebugSerialization |= Args.hasArg(OPT_sil_debug_serialization); Opts.EmitVerboseSIL |= Args.hasArg(OPT_emit_verbose_sil); Opts.PrintInstCounts |= Args.hasArg(OPT_print_inst_counts); if (const Arg *A = Args.getLastArg(OPT_external_pass_pipeline_filename)) Opts.ExternalPassPipelineFilename = A->getValue(); Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate); const Arg *ProfileUse = Args.getLastArg(OPT_profile_use); Opts.UseProfile = ProfileUse ? ProfileUse->getValue() : ""; Opts.EmitProfileCoverageMapping |= Args.hasArg(OPT_profile_coverage_mapping); Opts.DisableSILPartialApply |= Args.hasArg(OPT_disable_sil_partial_apply); Opts.EnableSILOwnership |= Args.hasArg(OPT_enable_sil_ownership); Opts.AssumeUnqualifiedOwnershipWhenParsing |= Args.hasArg(OPT_assume_parsing_unqualified_ownership_sil); Opts.EnableMandatorySemanticARCOpts |= !Args.hasArg(OPT_disable_mandatory_semantic_arc_opts); Opts.EnableLargeLoadableTypes |= Args.hasArg(OPT_enable_large_loadable_types); Opts.EnableGuaranteedNormalArguments &= !Args.hasArg(OPT_disable_guaranteed_normal_arguments); if (const Arg *A = Args.getLastArg(OPT_save_optimization_record_path)) Opts.OptRecordFile = A->getValue(); if (Args.hasArg(OPT_debug_on_sil)) { // Derive the name of the SIL file for debugging from // the regular outputfile. std::string BaseName = FEOpts.InputsAndOutputs.getSingleOutputFilename(); // If there are no or multiple outputfiles, derive the name // from the module name. if (BaseName.empty()) BaseName = FEOpts.ModuleName; Opts.SILOutputFileNameForDebugging = BaseName; } if (const Arg *A = Args.getLastArg(options::OPT_sanitize_EQ)) { Opts.Sanitizers = parseSanitizerArgValues( Args, A, Triple, Diags, /* sanitizerRuntimeLibExists= */[](StringRef libName, bool shared) { // The driver has checked the existence of the library // already. return true; }); IRGenOpts.Sanitizers = Opts.Sanitizers; } if (auto A = Args.getLastArg(OPT_enable_verify_exclusivity, OPT_disable_verify_exclusivity)) { Opts.VerifyExclusivity = A->getOption().matches(OPT_enable_verify_exclusivity); } if (Opts.shouldOptimize() && !Opts.VerifyExclusivity) Opts.EnforceExclusivityDynamic = false; if (const Arg *A = Args.getLastArg(options::OPT_enforce_exclusivity_EQ)) { parseExclusivityEnforcementOptions(A, Opts, Diags); } return false; }
static bool ParseLangArgs(LangOptions &Opts, ArgList &Args, DiagnosticEngine &Diags, const FrontendOptions &FrontendOpts) { using namespace options; /// FIXME: Remove this flag when void subscripts are implemented. /// This is used to guard preemptive testing for the fix-it. if (Args.hasArg(OPT_fix_string_substring_conversion)) { Opts.FixStringToSubstringConversions = true; } if (auto A = Args.getLastArg(OPT_swift_version)) { auto vers = version::Version::parseVersionString( A->getValue(), SourceLoc(), &Diags); bool isValid = false; if (vers.hasValue()) { if (auto effectiveVers = vers.getValue().getEffectiveLanguageVersion()) { Opts.EffectiveLanguageVersion = effectiveVers.getValue(); isValid = true; } } if (!isValid) diagnoseSwiftVersion(vers, A, Args, Diags); } Opts.AttachCommentsToDecls |= Args.hasArg(OPT_dump_api_path); Opts.UseMalloc |= Args.hasArg(OPT_use_malloc); Opts.DiagnosticsEditorMode |= Args.hasArg(OPT_diagnostics_editor_mode, OPT_serialize_diagnostics_path); Opts.EnableExperimentalPropertyBehaviors |= Args.hasArg(OPT_enable_experimental_property_behaviors); if (auto A = Args.getLastArg(OPT_enable_deserialization_recovery, OPT_disable_deserialization_recovery)) { Opts.EnableDeserializationRecovery = A->getOption().matches(OPT_enable_deserialization_recovery); } Opts.DisableAvailabilityChecking |= Args.hasArg(OPT_disable_availability_checking); Opts.DisableTsanInoutInstrumentation |= Args.hasArg(OPT_disable_tsan_inout_instrumentation); if (FrontendOpts.InputKind == InputFileKind::IFK_SIL) Opts.DisableAvailabilityChecking = true; if (auto A = Args.getLastArg(OPT_enable_access_control, OPT_disable_access_control)) { Opts.EnableAccessControl = A->getOption().matches(OPT_enable_access_control); } if (auto A = Args.getLastArg(OPT_disable_typo_correction, OPT_typo_correction_limit)) { if (A->getOption().matches(OPT_disable_typo_correction)) Opts.TypoCorrectionLimit = 0; else { unsigned limit; if (StringRef(A->getValue()).getAsInteger(10, limit)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.TypoCorrectionLimit = limit; } } Opts.CodeCompleteInitsInPostfixExpr |= Args.hasArg(OPT_code_complete_inits_in_postfix_expr); Opts.CodeCompleteCallPatternHeuristics |= Args.hasArg(OPT_code_complete_call_pattern_heuristics); if (auto A = Args.getLastArg(OPT_enable_target_os_checking, OPT_disable_target_os_checking)) { Opts.EnableTargetOSChecking = A->getOption().matches(OPT_enable_target_os_checking); } Opts.EnableASTScopeLookup |= Args.hasArg(OPT_enable_astscope_lookup); Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints); Opts.IterativeTypeChecker |= Args.hasArg(OPT_iterative_type_checker); Opts.NamedLazyMemberLoading &= !Args.hasArg(OPT_disable_named_lazy_member_loading); Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures); if (Args.hasArg(OPT_verify_syntax_tree)) { Opts.BuildSyntaxTree = true; Opts.VerifySyntaxTree = true; } Opts.DebuggerSupport |= Args.hasArg(OPT_debugger_support); if (Opts.DebuggerSupport) Opts.EnableDollarIdentifiers = true; Opts.Playground |= Args.hasArg(OPT_playground); Opts.InferImportAsMember |= Args.hasArg(OPT_enable_infer_import_as_member); Opts.EnableThrowWithoutTry |= Args.hasArg(OPT_enable_throw_without_try); if (auto A = Args.getLastArg(OPT_enable_objc_attr_requires_foundation_module, OPT_disable_objc_attr_requires_foundation_module)) { Opts.EnableObjCAttrRequiresFoundation = A->getOption().matches(OPT_enable_objc_attr_requires_foundation_module); } if (auto A = Args.getLastArg(OPT_enable_testable_attr_requires_testable_module, OPT_disable_testable_attr_requires_testable_module)) { Opts.EnableTestableAttrRequiresTestableModule = A->getOption().matches(OPT_enable_testable_attr_requires_testable_module); } if (const Arg *A = Args.getLastArg(OPT_debug_constraints_attempt)) { unsigned attempt; if (StringRef(A->getValue()).getAsInteger(10, attempt)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.DebugConstraintSolverAttempt = attempt; } if (const Arg *A = Args.getLastArg(OPT_debug_forbid_typecheck_prefix)) { Opts.DebugForbidTypecheckPrefix = A->getValue(); } if (const Arg *A = Args.getLastArg(OPT_solver_memory_threshold)) { unsigned threshold; if (StringRef(A->getValue()).getAsInteger(10, threshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.SolverMemoryThreshold = threshold; } if (const Arg *A = Args.getLastArg(OPT_solver_shrink_unsolved_threshold)) { unsigned threshold; if (StringRef(A->getValue()).getAsInteger(10, threshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.SolverShrinkUnsolvedThreshold = threshold; } if (const Arg *A = Args.getLastArg(OPT_value_recursion_threshold)) { unsigned threshold; if (StringRef(A->getValue()).getAsInteger(10, threshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.MaxCircularityDepth = threshold; } for (const Arg *A : Args.filtered(OPT_D)) { Opts.addCustomConditionalCompilationFlag(A->getValue()); } Opts.EnableAppExtensionRestrictions |= Args.hasArg(OPT_enable_app_extension); Opts.EnableSwift3ObjCInference = Args.hasFlag(OPT_enable_swift3_objc_inference, OPT_disable_swift3_objc_inference, Opts.isSwiftVersion3()); if (Opts.EnableSwift3ObjCInference) { if (const Arg *A = Args.getLastArg( OPT_warn_swift3_objc_inference_minimal, OPT_warn_swift3_objc_inference_complete)) { if (A->getOption().getID() == OPT_warn_swift3_objc_inference_minimal) Opts.WarnSwift3ObjCInference = Swift3ObjCInferenceWarnings::Minimal; else Opts.WarnSwift3ObjCInference = Swift3ObjCInferenceWarnings::Complete; } } Opts.EnableNSKeyedArchiverDiagnostics = Args.hasFlag(OPT_enable_nskeyedarchiver_diagnostics, OPT_disable_nskeyedarchiver_diagnostics, Opts.EnableNSKeyedArchiverDiagnostics); Opts.EnableNonFrozenEnumExhaustivityDiagnostics = Args.hasFlag(OPT_enable_nonfrozen_enum_exhaustivity_diagnostics, OPT_disable_nonfrozen_enum_exhaustivity_diagnostics, Opts.isSwiftVersionAtLeast(5)); if (Arg *A = Args.getLastArg(OPT_Rpass_EQ)) Opts.OptimizationRemarkPassedPattern = generateOptimizationRemarkRegex(Diags, Args, A); if (Arg *A = Args.getLastArg(OPT_Rpass_missed_EQ)) Opts.OptimizationRemarkMissedPattern = generateOptimizationRemarkRegex(Diags, Args, A); llvm::Triple Target = Opts.Target; StringRef TargetArg; if (const Arg *A = Args.getLastArg(OPT_target)) { Target = llvm::Triple(A->getValue()); TargetArg = A->getValue(); } Opts.EnableObjCInterop = Args.hasFlag(OPT_enable_objc_interop, OPT_disable_objc_interop, Target.isOSDarwin()); Opts.EnableSILOpaqueValues |= Args.hasArg(OPT_enable_sil_opaque_values); Opts.EnableKeyPathResilience |= Args.hasArg(OPT_enable_key_path_resilience); #if SWIFT_DARWIN_ENABLE_STABLE_ABI_BIT Opts.UseDarwinPreStableABIBit = false; #else Opts.UseDarwinPreStableABIBit = true; #endif // Must be processed after any other language options that could affect // platform conditions. bool UnsupportedOS, UnsupportedArch; std::tie(UnsupportedOS, UnsupportedArch) = Opts.setTarget(Target); SmallVector<StringRef, 3> TargetComponents; TargetArg.split(TargetComponents, "-"); if (UnsupportedArch) { auto TargetArgArch = TargetComponents.size() ? TargetComponents[0] : ""; Diags.diagnose(SourceLoc(), diag::error_unsupported_target_arch, TargetArgArch); } if (UnsupportedOS) { auto TargetArgOS = TargetComponents.size() > 2 ? TargetComponents[2] : ""; Diags.diagnose(SourceLoc(), diag::error_unsupported_target_os, TargetArgOS); } return UnsupportedOS || UnsupportedArch; }
/// Emits a Swift-style dependencies file. static bool emitReferenceDependencies(DiagnosticEngine &diags, SourceFile *SF, DependencyTracker &depTracker, const FrontendOptions &opts) { if (!SF) { diags.diagnose(SourceLoc(), diag::emit_reference_dependencies_without_primary_file); return true; } std::error_code EC; llvm::raw_fd_ostream out(opts.ReferenceDependenciesFilePath, EC, llvm::sys::fs::F_None); if (out.has_error() || EC) { diags.diagnose(SourceLoc(), diag::error_opening_output, opts.ReferenceDependenciesFilePath, EC.message()); out.clear_error(); return true; } auto escape = [](Identifier name) -> std::string { return llvm::yaml::escape(name.str()); }; out << "### Swift dependencies file v0 ###\n"; llvm::MapVector<const NominalTypeDecl *, bool> extendedNominals; llvm::SmallVector<const ExtensionDecl *, 8> extensionsWithJustMembers; out << "provides-top-level:\n"; for (const Decl *D : SF->Decls) { switch (D->getKind()) { case DeclKind::Module: break; case DeclKind::Import: // FIXME: Handle re-exported decls. break; case DeclKind::Extension: { auto *ED = cast<ExtensionDecl>(D); auto *NTD = ED->getExtendedType()->getAnyNominal(); if (!NTD) break; if (NTD->hasAccessibility() && NTD->getFormalAccess() == Accessibility::Private) { break; } bool justMembers = std::all_of(ED->getInherited().begin(), ED->getInherited().end(), extendedTypeIsPrivate); if (justMembers) { if (std::all_of(ED->getMembers().begin(), ED->getMembers().end(), declIsPrivate)) { break; } else { extensionsWithJustMembers.push_back(ED); } } extendedNominals[NTD] |= !justMembers; findNominals(extendedNominals, ED->getMembers()); break; } case DeclKind::InfixOperator: case DeclKind::PrefixOperator: case DeclKind::PostfixOperator: out << "- \"" << escape(cast<OperatorDecl>(D)->getName()) << "\"\n"; break; case DeclKind::Enum: case DeclKind::Struct: case DeclKind::Class: case DeclKind::Protocol: { auto *NTD = cast<NominalTypeDecl>(D); if (!NTD->hasName()) break; if (NTD->hasAccessibility() && NTD->getFormalAccess() == Accessibility::Private) { break; } out << "- \"" << escape(NTD->getName()) << "\"\n"; extendedNominals[NTD] |= true; findNominals(extendedNominals, NTD->getMembers()); break; } case DeclKind::TypeAlias: case DeclKind::Var: case DeclKind::Func: { auto *VD = cast<ValueDecl>(D); if (!VD->hasName()) break; if (VD->hasAccessibility() && VD->getFormalAccess() == Accessibility::Private) { break; } out << "- \"" << escape(VD->getName()) << "\"\n"; break; } case DeclKind::PatternBinding: case DeclKind::TopLevelCode: case DeclKind::IfConfig: // No action necessary. break; case DeclKind::EnumCase: case DeclKind::GenericTypeParam: case DeclKind::AssociatedType: case DeclKind::Param: case DeclKind::Subscript: case DeclKind::Constructor: case DeclKind::Destructor: case DeclKind::EnumElement: llvm_unreachable("cannot appear at the top level of a file"); } } out << "provides-nominal:\n"; for (auto entry : extendedNominals) { if (!entry.second) continue; out << "- \""; mangleTypeAsContext(out, entry.first); out << "\"\n"; } out << "provides-member:\n"; for (auto entry : extendedNominals) { out << "- [\""; mangleTypeAsContext(out, entry.first); out << "\", \"\"]\n"; } // This is also part of "provides-member". for (auto *ED : extensionsWithJustMembers) { SmallString<32> mangledName; mangleTypeAsContext(llvm::raw_svector_ostream(mangledName), ED->getExtendedType()->getAnyNominal()); for (auto *member : ED->getMembers()) { auto *VD = dyn_cast<ValueDecl>(member); if (!VD || !VD->hasName() || VD->getFormalAccess() == Accessibility::Private) { continue; } out << "- [\"" << mangledName.str() << "\", \"" << escape(VD->getName()) << "\"]\n"; } } if (SF->getASTContext().LangOpts.EnableObjCInterop) { // FIXME: This requires a traversal of the whole file to compute. // We should (a) see if there's a cheaper way to keep it up to date, // and/or (b) see if we can fast-path cases where there's no ObjC involved. out << "provides-dynamic-lookup:\n"; class ValueDeclPrinter : public VisibleDeclConsumer { private: raw_ostream &out; std::string (*escape)(Identifier); public: ValueDeclPrinter(raw_ostream &out, decltype(escape) escape) : out(out), escape(escape) {} void foundDecl(ValueDecl *VD, DeclVisibilityKind Reason) override { out << "- \"" << escape(VD->getName()) << "\"\n"; } }; ValueDeclPrinter printer(out, escape); SF->lookupClassMembers({}, printer); } ReferencedNameTracker *tracker = SF->getReferencedNameTracker(); // FIXME: Sort these? out << "depends-top-level:\n"; for (auto &entry : tracker->getTopLevelNames()) { assert(!entry.first.empty()); out << "- "; if (!entry.second) out << "!private "; out << "\"" << escape(entry.first) << "\"\n"; } out << "depends-member:\n"; auto &memberLookupTable = tracker->getUsedMembers(); using TableEntryTy = std::pair<ReferencedNameTracker::MemberPair, bool>; std::vector<TableEntryTy> sortedMembers{ memberLookupTable.begin(), memberLookupTable.end() }; llvm::array_pod_sort(sortedMembers.begin(), sortedMembers.end(), [](const TableEntryTy *lhs, const TableEntryTy *rhs) -> int { if (lhs->first.first == rhs->first.first) return lhs->first.second.compare(rhs->first.second); if (lhs->first.first->getName() != rhs->first.first->getName()) return lhs->first.first->getName().compare(rhs->first.first->getName()); // Break type name ties by mangled name. SmallString<32> lhsMangledName, rhsMangledName; mangleTypeAsContext(llvm::raw_svector_ostream(lhsMangledName), lhs->first.first); mangleTypeAsContext(llvm::raw_svector_ostream(rhsMangledName), rhs->first.first); return lhsMangledName.str().compare(rhsMangledName.str()); }); for (auto &entry : sortedMembers) { assert(entry.first.first != nullptr); if (entry.first.first->hasAccessibility() && entry.first.first->getFormalAccess() == Accessibility::Private) continue; out << "- "; if (!entry.second) out << "!private "; out << "[\""; mangleTypeAsContext(out, entry.first.first); out << "\", \""; if (!entry.first.second.empty()) out << escape(entry.first.second); out << "\"]\n"; } out << "depends-nominal:\n"; for (auto i = sortedMembers.begin(), e = sortedMembers.end(); i != e; ++i) { bool isCascading = i->second; while (i+1 != e && i[0].first.first == i[1].first.first) { ++i; isCascading |= i->second; } if (i->first.first->hasAccessibility() && i->first.first->getFormalAccess() == Accessibility::Private) continue; out << "- "; if (!isCascading) out << "!private "; out << "\""; mangleTypeAsContext(out, i->first.first); out << "\"\n"; } // FIXME: Sort these? out << "depends-dynamic-lookup:\n"; for (auto &entry : tracker->getDynamicLookupNames()) { assert(!entry.first.empty()); out << "- "; if (!entry.second) out << "!private "; out << "\"" << escape(entry.first) << "\"\n"; } out << "depends-external:\n"; for (auto &entry : depTracker.getDependencies()) { out << "- \"" << llvm::yaml::escape(entry) << "\"\n"; } llvm::SmallString<32> interfaceHash; SF->getInterfaceHash(interfaceHash); out << "interface-hash: \"" << interfaceHash << "\"\n"; return false; }
static bool ParseLangArgs(LangOptions &Opts, ArgList &Args, DiagnosticEngine &Diags, bool isImmediate) { using namespace options; Opts.AttachCommentsToDecls |= Args.hasArg(OPT_dump_api_path); Opts.UseMalloc |= Args.hasArg(OPT_use_malloc); Opts.EnableExperimentalPatterns |= Args.hasArg(OPT_enable_experimental_patterns); Opts.DisableAvailabilityChecking |= Args.hasArg(OPT_disable_availability_checking); if (auto A = Args.getLastArg(OPT_enable_access_control, OPT_disable_access_control)) { Opts.EnableAccessControl = A->getOption().matches(OPT_enable_access_control); } Opts.CodeCompleteInitsInPostfixExpr |= Args.hasArg(OPT_code_complete_inits_in_postfix_expr); if (auto A = Args.getLastArg(OPT_enable_target_os_checking, OPT_disable_target_os_checking)) { Opts.EnableTargetOSChecking = A->getOption().matches(OPT_enable_target_os_checking); } Opts.DebugConstraintSolver |= Args.hasArg(OPT_debug_constraints); Opts.IterativeTypeChecker |= Args.hasArg(OPT_iterative_type_checker); Opts.DebugGenericSignatures |= Args.hasArg(OPT_debug_generic_signatures); Opts.DebuggerSupport |= Args.hasArg(OPT_debugger_support); if (Opts.DebuggerSupport) Opts.EnableDollarIdentifiers = true; Opts.Playground |= Args.hasArg(OPT_playground); Opts.Swift3Migration |= Args.hasArg(OPT_swift3_migration); Opts.WarnOmitNeedlessWords = Args.hasArg(OPT_warn_omit_needless_words); Opts.OmitNeedlessWords |= Args.hasArg(OPT_enable_omit_needless_words); Opts.StripNSPrefix = Args.hasArg(OPT_enable_strip_ns_prefix); Opts.EnableThrowWithoutTry |= Args.hasArg(OPT_enable_throw_without_try); if (auto A = Args.getLastArg(OPT_enable_objc_attr_requires_foundation_module, OPT_disable_objc_attr_requires_foundation_module)) { Opts.EnableObjCAttrRequiresFoundation = A->getOption().matches(OPT_enable_objc_attr_requires_foundation_module); } if (auto A = Args.getLastArg(OPT_enable_testable_attr_requires_testable_module, OPT_disable_testable_attr_requires_testable_module)) { Opts.EnableTestableAttrRequiresTestableModule = A->getOption().matches(OPT_enable_testable_attr_requires_testable_module); } if (const Arg *A = Args.getLastArg(OPT_debug_constraints_attempt)) { unsigned attempt; if (StringRef(A->getValue()).getAsInteger(10, attempt)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.DebugConstraintSolverAttempt = attempt; } if (const Arg *A = Args.getLastArg(OPT_debug_forbid_typecheck_prefix)) { Opts.DebugForbidTypecheckPrefix = A->getValue(); } if (const Arg *A = Args.getLastArg(OPT_solver_memory_threshold)) { unsigned threshold; if (StringRef(A->getValue()).getAsInteger(10, threshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } Opts.SolverMemoryThreshold = threshold; } for (const Arg *A : make_range(Args.filtered_begin(OPT_D), Args.filtered_end())) { Opts.addCustomConditionalCompilationFlag(A->getValue()); } Opts.EnableAppExtensionRestrictions |= Args.hasArg(OPT_enable_app_extension); llvm::Triple Target = Opts.Target; StringRef TargetArg; if (const Arg *A = Args.getLastArg(OPT_target)) { Target = llvm::Triple(A->getValue()); TargetArg = A->getValue(); } Opts.EnableObjCInterop = Target.isOSDarwin(); if (auto A = Args.getLastArg(OPT_enable_objc_interop, OPT_disable_objc_interop)) { Opts.EnableObjCInterop = A->getOption().matches(OPT_enable_objc_interop); } // Must be processed after any other language options that could affect // platform conditions. bool UnsupportedOS, UnsupportedArch; std::tie(UnsupportedOS, UnsupportedArch) = Opts.setTarget(Target); SmallVector<StringRef, 3> TargetComponents; TargetArg.split(TargetComponents, "-"); if (UnsupportedArch) { auto TargetArgArch = TargetComponents.size() ? TargetComponents[0] : ""; Diags.diagnose(SourceLoc(), diag::error_unsupported_target_arch, TargetArgArch); } if (UnsupportedOS) { auto TargetArgOS = TargetComponents.size() > 2 ? TargetComponents.back() : ""; Diags.diagnose(SourceLoc(), diag::error_unsupported_target_os, TargetArgOS); } return UnsupportedOS || UnsupportedArch; }
static bool ParseSILArgs(SILOptions &Opts, ArgList &Args, IRGenOptions &IRGenOpts, FrontendOptions &FEOpts, DiagnosticEngine &Diags) { using namespace options; if (const Arg *A = Args.getLastArg(OPT_sil_inline_threshold)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.InlineThreshold)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (const Arg *A = Args.getLastArg(OPT_num_threads)) { if (StringRef(A->getValue()).getAsInteger(10, Opts.NumThreads)) { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } if (const Arg *A = Args.getLastArg(OPT_disable_sil_linking, OPT_sil_link_all)) { if (A->getOption().matches(OPT_disable_sil_linking)) Opts.LinkMode = SILOptions::LinkNone; else if (A->getOption().matches(OPT_sil_link_all)) Opts.LinkMode = SILOptions::LinkAll; else llvm_unreachable("Unknown SIL linking option!"); } // Parse the optimization level. if (const Arg *A = Args.getLastArg(OPT_O_Group)) { if (A->getOption().matches(OPT_Onone)) { IRGenOpts.Optimize = false; Opts.Optimization = SILOptions::SILOptMode::None; } else if (A->getOption().matches(OPT_Ounchecked)) { // Turn on optimizations and remove all runtime checks. IRGenOpts.Optimize = true; Opts.Optimization = SILOptions::SILOptMode::OptimizeUnchecked; // Removal of cond_fail (overflow on binary operations). Opts.RemoveRuntimeAsserts = true; Opts.AssertConfig = SILOptions::Unchecked; } else if (A->getOption().matches(OPT_Oplayground)) { // For now -Oplayground is equivalent to -Onone. IRGenOpts.Optimize = false; Opts.Optimization = SILOptions::SILOptMode::None; } else { assert(A->getOption().matches(OPT_O)); IRGenOpts.Optimize = true; Opts.Optimization = SILOptions::SILOptMode::Optimize; } } // Parse the assert configuration identifier. if (const Arg *A = Args.getLastArg(OPT_AssertConfig)) { StringRef Configuration = A->getValue(); if (Configuration == "DisableReplacement") { Opts.AssertConfig = SILOptions::DisableReplacement; } else if (Configuration == "Debug") { Opts.AssertConfig = SILOptions::Debug; } else if (Configuration == "Release") { Opts.AssertConfig = SILOptions::Release; } else if (Configuration == "Unchecked") { Opts.AssertConfig = SILOptions::Unchecked; } else { Diags.diagnose(SourceLoc(), diag::error_invalid_arg_value, A->getAsString(Args), A->getValue()); return true; } } else if (FEOpts.ParseStdlib) { // Disable assertion configuration replacement when we build the standard // library. Opts.AssertConfig = SILOptions::DisableReplacement; } else if (Opts.AssertConfig == SILOptions::Debug) { // Set the assert configuration according to the optimization level if it // has not been set by the -Ounchecked flag. Opts.AssertConfig = IRGenOpts.Optimize ? SILOptions::Release : SILOptions::Debug; } // -Ounchecked might also set removal of runtime asserts (cond_fail). Opts.RemoveRuntimeAsserts |= Args.hasArg(OPT_remove_runtime_asserts); Opts.EnableARCOptimizations |= !Args.hasArg(OPT_disable_arc_opts); Opts.VerifyAll |= Args.hasArg(OPT_sil_verify_all); Opts.DebugSerialization |= Args.hasArg(OPT_sil_debug_serialization); Opts.EmitVerboseSIL |= Args.hasArg(OPT_emit_verbose_sil); Opts.PrintInstCounts |= Args.hasArg(OPT_print_inst_counts); if (const Arg *A = Args.getLastArg(OPT_external_pass_pipeline_filename)) Opts.ExternalPassPipelineFilename = A->getValue(); Opts.GenerateProfile |= Args.hasArg(OPT_profile_generate); Opts.EmitProfileCoverageMapping |= Args.hasArg(OPT_profile_coverage_mapping); Opts.EnableGuaranteedClosureContexts |= Args.hasArg(OPT_enable_guaranteed_closure_contexts); return false; }
int frontend_main(ArrayRef<const char *>Args, const char *Argv0, void *MainAddr) { llvm::InitializeAllTargets(); llvm::InitializeAllTargetMCs(); llvm::InitializeAllAsmPrinters(); llvm::InitializeAllAsmParsers(); CompilerInstance Instance; PrintingDiagnosticConsumer PDC; Instance.addDiagnosticConsumer(&PDC); if (Args.empty()) { Instance.getDiags().diagnose(SourceLoc(), diag::error_no_frontend_args); return 1; } CompilerInvocation Invocation; std::string MainExecutablePath = llvm::sys::fs::getMainExecutable(Argv0, MainAddr); Invocation.setMainExecutablePath(MainExecutablePath); SmallString<128> workingDirectory; llvm::sys::fs::current_path(workingDirectory); // Parse arguments. if (Invocation.parseArgs(Args, Instance.getDiags(), workingDirectory)) { return 1; } if (Invocation.getFrontendOptions().PrintHelp || Invocation.getFrontendOptions().PrintHelpHidden) { unsigned IncludedFlagsBitmask = options::FrontendOption; unsigned ExcludedFlagsBitmask = Invocation.getFrontendOptions().PrintHelpHidden ? 0 : llvm::opt::HelpHidden; std::unique_ptr<llvm::opt::OptTable> Options(createSwiftOptTable()); Options->PrintHelp(llvm::outs(), displayName(MainExecutablePath).c_str(), "Swift frontend", IncludedFlagsBitmask, ExcludedFlagsBitmask); return 0; } if (Invocation.getFrontendOptions().RequestedAction == FrontendOptions::NoneAction) { Instance.getDiags().diagnose(SourceLoc(), diag::error_missing_frontend_action); return 1; } // TODO: reorder, if possible, so that diagnostics emitted during // CompilerInvocation::parseArgs are included in the serialized file. std::unique_ptr<DiagnosticConsumer> SerializedConsumer; { const std::string &SerializedDiagnosticsPath = Invocation.getFrontendOptions().SerializedDiagnosticsPath; if (!SerializedDiagnosticsPath.empty()) { std::error_code EC; std::unique_ptr<llvm::raw_fd_ostream> OS; OS.reset(new llvm::raw_fd_ostream(SerializedDiagnosticsPath, EC, llvm::sys::fs::F_None)); if (EC) { Instance.getDiags().diagnose(SourceLoc(), diag::cannot_open_serialized_file, SerializedDiagnosticsPath, EC.message()); return 1; } SerializedConsumer.reset( serialized_diagnostics::createConsumer(std::move(OS))); Instance.addDiagnosticConsumer(SerializedConsumer.get()); } } std::unique_ptr<DiagnosticConsumer> FixitsConsumer; { const std::string &FixitsOutputPath = Invocation.getFrontendOptions().FixitsOutputPath; if (!FixitsOutputPath.empty()) { std::error_code EC; std::unique_ptr<llvm::raw_fd_ostream> OS; OS.reset(new llvm::raw_fd_ostream(FixitsOutputPath, EC, llvm::sys::fs::F_None)); if (EC) { Instance.getDiags().diagnose(SourceLoc(), diag::cannot_open_file, FixitsOutputPath, EC.message()); return 1; } FixitsConsumer.reset(new JSONFixitWriter(std::move(OS), Invocation.getDiagnosticOptions())); Instance.addDiagnosticConsumer(FixitsConsumer.get()); } } if (Invocation.getDiagnosticOptions().UseColor) PDC.forceColors(); if (Invocation.getFrontendOptions().PrintStats) { llvm::EnableStatistics(); } if (Invocation.getDiagnosticOptions().VerifyDiagnostics) { enableDiagnosticVerifier(Instance.getSourceMgr()); } DependencyTracker depTracker; if (!Invocation.getFrontendOptions().DependenciesFilePath.empty() || !Invocation.getFrontendOptions().ReferenceDependenciesFilePath.empty()) { Instance.setDependencyTracker(&depTracker); } if (Instance.setup(Invocation)) { return 1; } int ReturnValue = 0; bool HadError = performCompile(Instance, Invocation, Args, ReturnValue) || Instance.getASTContext().hadError(); if (!HadError && !Invocation.getFrontendOptions().DumpAPIPath.empty()) { HadError = dumpAPI(Instance.getMainModule(), Invocation.getFrontendOptions().DumpAPIPath); } if (Invocation.getDiagnosticOptions().VerifyDiagnostics) { HadError = verifyDiagnostics(Instance.getSourceMgr(), Instance.getInputBufferIDs()); DiagnosticEngine &diags = Instance.getDiags(); if (diags.hasFatalErrorOccurred() && !Invocation.getDiagnosticOptions().ShowDiagnosticsAfterFatalError) { diags.resetHadAnyError(); diags.diagnose(SourceLoc(), diag::verify_encountered_fatal); HadError = true; } } return (HadError ? 1 : ReturnValue); }