Lines Matching +full:all +full:- +full:inputs
1 //===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===//
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //===----------------------------------------------------------------------===//
73 #include "llvm/Config/llvm-config.h"
133 return llvm::Triple(HostTriple.isArch64Bit() ? "nvptx64-nvidia-cuda"
134 : "nvptx-nvidia-cuda");
137 if (TT && (TT->getArch() == llvm::Triple::spirv32 ||
138 TT->getArch() == llvm::Triple::spirv64)) {
144 D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
153 return llvm::Triple("spirv64-amd-amdhsa");
154 // Mixing specific & SPIR-V compilation is not supported for now.
158 return llvm::Triple("amdgcn-amd-amdhsa"); // Default HIP triple.
163 if (TT->getArch() == llvm::Triple::amdgcn &&
164 TT->getVendor() == llvm::Triple::AMD &&
165 TT->getOS() == llvm::Triple::AMDHSA)
167 if (TT->getArch() == llvm::Triple::spirv64)
169 D.Diag(diag::err_drv_invalid_or_unsupported_offload_target) << TT->str();
177 // that all places that need it call this function, so that they get the
188 // On non-Windows, libclang.so/.dylib is in lib/.
189 // With a static-library build of libclang, LibClangPath will contain the
217 if (!this->VFS)
218 this->VFS = llvm::vfs::getRealFileSystem();
282 if (A->getOption().hasFlag(options::Unsupported)) {
283 Diag(diag::err_drv_unsupported_opt) << A->getAsString(Args);
290 // Warn about -mcpu= without an argument.
291 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue("")) {
292 Diag(diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
301 auto ArgString = A->getAsString(Args);
308 Diags.Report(DiagID) << ArgString << "-Xclang " + Nearest;
325 if (ArgStrings[A->getIndex()] == A->getSpelling())
329 std::string ArgString = ArgStrings[A->getIndex()];
331 if (getOpts().findExact("-" + ArgString, Nearest, VisibilityMask))
333 << A->getAsString(Args) << Nearest;
347 // -{E,EP,P,M,MM} only run the preprocessor.
355 // --precompile only runs up to precompilation.
363 // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
377 // -S only runs up to the backend.
381 // -c compilation only runs up to the assembler.
404 A->claim();
418 A->claim();
420 if (A->getOption().matches(options::OPT_start_no_unused_arguments)) {
424 if (A->getOption().matches(options::OPT_end_no_unused_arguments)) {
429 // Unfortunately, we have to parse some forwarding options (-Xassembler,
430 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
433 // Rewrite linker options, to replace --no-demangle with a custom internal
435 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
436 A->getOption().matches(options::OPT_Xlinker)) &&
437 A->containsValue("--no-demangle")) {
438 // Add the rewritten no-demangle argument.
439 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_Xlinker__no_demangle));
442 for (StringRef Val : A->getValues())
443 if (Val != "--no-demangle")
444 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_Xlinker), Val);
449 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
452 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
453 (A->getValue(0) == StringRef("-MD") ||
454 A->getValue(0) == StringRef("-MMD"))) {
455 // Rewrite to -MD/-MMD along with -MF.
456 if (A->getValue(0) == StringRef("-MD"))
457 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MD));
459 DAL->AddFlagArg(A, Opts.getOption(options::OPT_MMD));
460 if (A->getNumValues() == 2)
461 DAL->AddSeparateArg(A, Opts.getOption(options::OPT_MF), A->getValue(1));
466 if (A->getOption().matches(options::OPT_l)) {
467 StringRef Value = A->getValue();
469 // Rewrite unless -nostdlib is present.
472 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_stdcxx));
478 DAL->AddFlagArg(A, Opts.getOption(options::OPT_Z_reserved_lib_cckext));
483 // Pick up inputs via the -- option.
484 if (A->getOption().matches(options::OPT__DASH_DASH)) {
485 A->claim();
486 for (StringRef Val : A->getValues())
487 DAL->append(MakeInputArg(*DAL, Opts, Val, false));
491 DAL->append(A);
496 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_S));
498 // Enforce -static if -miamcu is present.
500 DAL->AddFlagArg(nullptr, Opts.getOption(options::OPT_static));
502 // Add a default value of -mlinker-version=, if one was given and the user
507 DAL->AddJoinedArg(0, Opts.getOption(options::OPT_mlinker_version_EQ),
509 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
526 TargetTriple = A->getValue();
530 // GNU/Hurd's triples should have been -hurd-gnu*, but were historically made
531 // -gnu* only, and we can not change this, so we have to detect that case as
533 if (TargetTriple.contains("-unknown-gnu") || TargetTriple.contains("-pc-gnu"))
536 // Handle Apple-specific options available here.
538 // If an explicit Darwin arch name is given, that trumps all.
545 // Handle the Darwin '-arch' flag.
547 StringRef ArchName = A->getValue();
552 // Handle pseudo-target flags '-mlittle-endian'/'-EL' and
553 // '-mbig-endian'/'-EB'.
556 llvm::Triple T = A->getOption().matches(options::OPT_mlittle_endian)
565 // Skip further flag support on OSes which don't support '-m32' or '-m64'.
589 // The `-maix[32|64]` flags are only valid for AIX targets.
593 << A->getAsString(Args) << Target.str();
595 // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'.
602 if (A->getOption().matches(options::OPT_m64) ||
603 A->getOption().matches(options::OPT_maix64)) {
610 } else if (A->getOption().matches(options::OPT_mx32) &&
617 } else if (A->getOption().matches(options::OPT_m32) ||
618 A->getOption().matches(options::OPT_maix32)) {
624 } else if (A->getOption().matches(options::OPT_m16) &&
637 // Handle -miamcu flag.
640 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu"
643 if (A && !A->getOption().matches(options::OPT_m32))
645 << "-miamcu" << A->getBaseArg().getAsString(Args);
660 StringRef ABIName = A->getValue();
682 // If target is RISC-V adjust the target triple according to
691 unsigned XLen = (*ISAInfo)->getXLen();
704 // based on which -f(no-)?lto(=.*)? or -f(no-)?offload-lto(=.*)?
712 StringRef LTOName = A->getValue();
721 << A->getSpelling() << A->getValue();
735 // Try to enable `-foffload-lto=full` if `-fopenmp-target-jit` is on.
742 << A->getSpelling() << "-fopenmp-target-jit";
753 RuntimeName = A->getValue();
764 << A->getSpelling() << A->getValue();
767 Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
774 InputList &Inputs) {
779 // We need to generate a CUDA/HIP toolchain if any of the inputs has a CUDA
782 llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
786 llvm::any_of(Inputs,
798 const llvm::Triple &HostTriple = HostTC->getTriple();
806 auto &CudaTC = ToolChains[CudaTriple->str() + "/" + HostTriple.str()];
822 << OMPTargetArg->getSpelling() << "HIP";
840 // the -fopenmp-targets option or used --offload-arch with OpenMP enabled.
847 // We expect that -fopenmp-targets is always used in conjunction with the
848 // option -fopenmp specifying a valid runtime with offloading support, i.e.
860 // If the user specified -fopenmp-targets= we create a toolchain for each
861 // valid triple. Otherwise, if only --offload-arch= was specified we instead
865 if (OpenMPTargets && !OpenMPTargets->getNumValues()) {
867 << OpenMPTargets->getAsString(C.getInputArgs());
870 for (StringRef T : OpenMPTargets->getValues())
877 HostTC->getTriple());
907 DerivedArchs[NVPTXTriple->getTriple()].insert(Arch);
911 DerivedArchs[AMDTriple->getTriple()].insert(Arch);
937 << Val << Duplicate->second;
957 ToolChains[TT.str() + "/" + HostTC->getTriple().normalize()];
992 unsigned Index = Args.MakeIndex(Opt->getSpelling());
993 Arg *Copy = new llvm::opt::Arg(Opt->getOption(), Args.getArgString(Index),
995 Copy->getValues() = Opt->getValues();
996 if (Opt->isClaimed())
997 Copy->claim();
998 Copy->setOwnsValues(Opt->getOwnsValues());
999 Opt->setOwnsValues(false);
1012 if (Status->getType() != llvm::sys::fs::file_type::regular_file) {
1035 // Claim all arguments that come from a configuration file so that the driver
1038 A->claim();
1045 const Arg *BaseArg = &Opt->getBaseArg();
1062 if (CLOptions->hasArg(options::OPT_config_system_dir_EQ)) {
1065 CLOptions->getLastArgValue(options::OPT_config_system_dir_EQ));
1071 if (CLOptions->hasArg(options::OPT_config_user_dir_EQ)) {
1074 CLOptions->getLastArgValue(options::OPT_config_user_dir_EQ), CfgDir);
1093 for (auto CfgFileName : CLOptions->getAllArgValues(options::OPT_config)) {
1125 // Disable default config if CLANG_NO_DEFAULT_CONFIG is set to a non-empty
1131 if (CLOptions && CLOptions->hasArg(options::OPT_no_default_config))
1137 // If name prefix is present, no --target= override was passed via CLOptions
1158 // 1. <triple>-<mode>.cfg using real driver mode
1159 // (e.g. i386-pc-linux-gnu-clang++.cfg).
1160 // 2. <triple>-<mode>.cfg using executable suffix
1161 // (e.g. i386-pc-linux-gnu-clang-g++.cfg for *clang-g++).
1163 // (e.g. i386-pc-linux-gnu.cfg + clang++.cfg).
1165 // (e.g. i386-pc-linux-gnu.cfg + clang-g++.cfg for *clang-g++).
1167 // Try loading <triple>-<mode>.cfg, and return if we find a match.
1169 std::string CfgFileName = Triple + '-' + RealMode + ".cfg";
1176 CfgFileName = Triple + '-' + ClangNameParts.ModeSuffix + ".cfg";
1217 // FIXME: What are we going to do with -V and -b?
1229 // All arguments, from both config file and command line.
1235 if (Opt->getOption().matches(options::OPT_config))
1237 const Arg *BaseArg = &Opt->getBaseArg();
1243 // In CL mode, look for any pass-through arguments
1247 A->claim();
1248 CLModePassThroughArgList.push_back(A->getValue());
1253 // than clang-cl processing.
1267 if (VFS->setCurrentWorkingDirectory(WD->getValue()))
1268 Diag(diag::err_drv_unable_to_set_working_directory) << WD->getValue();
1273 if (!VFS->exists(IncludeDir))
1281 // -canonical-prefixes, -no-canonical-prefixes are used very early in main.
1285 // f(no-)integated-cc1 is also used very early in main.
1289 // Ignore -pipe.
1292 // Extract -ccc args.
1296 // options, either by introducing new ones or by overloading gcc ones like -V
1297 // or -b.
1301 CCCGenericGCCName = A->getValue();
1303 // Process -fproc-stat-report options.
1306 CCPrintStatReportFilename = A->getValue();
1311 // FIXME: TargetTriple is used by the target-prefixed calls to as/ld
1314 // clang-cl targets MSVC-style Win32.
1324 // Build TargetTriple from target_profile option for clang-dxc.
1326 StringRef TargetProfile = A->getValue();
1333 A->claim();
1343 if (ValidValues.contains(A->getValue())) {
1344 T.setOSName(A->getValue());
1347 << A->getAsString(Args) << A->getValue();
1349 A->claim();
1360 TargetTriple = A->getValue();
1362 Dir = Dir = A->getValue();
1364 A->claim();
1365 PrefixDirs.push_back(A->getValue(0));
1378 SysRoot = A->getValue();
1380 DyldPrefix = A->getValue();
1383 ResourceDir = A->getValue();
1386 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
1395 if (A->getOption().matches(options::OPT_offload_host_only))
1397 else if (A->getOption().matches(options::OPT_offload_device_only))
1405 // Process -fembed-bitcode= flags.
1407 StringRef Name = A->getValue();
1410 .Case("all", EmbedBitcode)
1415 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
1423 llvm::sys::fs::remove(A->getValue());
1432 (Std->containsValue("c++20") || Std->containsValue("c++2a") ||
1433 Std->containsValue("c++23") || Std->containsValue("c++2b") ||
1434 Std->containsValue("c++26") || Std->containsValue("c++2c") ||
1435 Std->containsValue("c++latest"));
1437 // Process -fmodule-header{=} flags.
1442 if (A->getOption().matches(options::OPT_fmodule_header))
1445 StringRef ArgName = A->getValue();
1452 << A->getAsString(Args) << ArgName;
1485 UArgs->hasArg(options::OPT__SLASH_arm64EC)) {
1490 // A common user mistake is specifying a target of aarch64-none-eabi or
1491 // arm-none-elf whereas the correct names are aarch64-none-elf &
1492 // arm-none-eabi. Detect these cases and issue a warning.
1503 << (TC.getTriple().getArchName().str() + "-none-eabi");
1512 << (TC.getTriple().getArchName().str() + "-none-elf");
1527 // Construct the list of inputs.
1528 InputList Inputs;
1529 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
1532 CreateOffloadingDeviceToolChains(*C, Inputs);
1535 // MachO targets this uses the driver-driver and universal actions.
1537 BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs);
1539 BuildActions(*C, C->getArgs(), Inputs, C->getActions());
1555 // `/source-charset:utf-8` instead of `-finput-charset=utf-8` if the user
1557 while (A->getAlias())
1558 A = A->getAlias();
1559 A->render(Args, ASL);
1578 // clang-<VERSION>_<YYYY-MM-DD-HHMMSS>_<hostname>.crash.
1597 StringRef FileName = path::filename(File->path());
1600 if (fs::status(File->path(), FileStatus))
1603 llvm::MemoryBuffer::getFile(File->path());
1608 StringRef Data = CrashFile.get()->getBuffer();
1611 // Parse parent process pid line, e.g: "Parent Process: clang-4.0 [79141]"
1619 int OpenBracket = -1, CloseBracket = -1;
1643 CrashFilePath.assign(File->path());
1675 Level = llvm::StringSwitch<unsigned>(A->getValue())
1678 .Case("all", 2)
1695 // If lld crashed, we will re-run the same command with the input it used
1719 // If lld failed, rerun it again with --reproduce.
1721 const char *TmpName = CreateTempFile(C, "linker-crash", "tar");
1727 : "--reproduce=";
1738 Report->TemporaryFiles.push_back(TmpName);
1742 // Construct the list of inputs.
1743 InputList Inputs;
1744 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
1746 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
1749 // Ignore input from stdin or any inputs that cannot be preprocessed.
1750 // Check type first as not all linker inputs have a value.
1751 if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
1753 } else if (!strcmp(it->second->getValue(), "-")) {
1755 << "Error generating preprocessed source(s) - "
1761 it = Inputs.erase(it);
1762 ie = Inputs.end();
1768 if (Inputs.empty()) {
1770 << "Error generating preprocessed source(s) - "
1771 "no preprocessable inputs.";
1775 // Don't attempt to generate preprocessed files if multiple -arch options are
1776 // used, unless they're all duplicates.
1779 if (A->getOption().matches(options::OPT_arch)) {
1780 StringRef ArchName = A->getValue();
1786 << "Error generating preprocessed source(s) - cannot generate "
1787 "preprocessed source with multiple -arch options.";
1792 // Darwin OSes this uses the driver-driver and builds universal actions.
1795 BuildUniversalActions(C, TC, Inputs);
1797 BuildActions(C, C.getArgs(), Inputs, C.getActions());
1833 Report->TemporaryFiles.push_back(TempFile);
1872 Report->TemporaryFiles.push_back(std::string(Script));
1884 CrashDiagDir += "_<YYYY-MM-DD-HHMMSS>_<hostname>.crash";
1929 // Just print if -### was present.
1958 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
1975 // This is ad-hoc, but we don't want to be excessively noisy. If the result
1980 const Tool &FailingTool = FailingCommand->getCreator();
1982 if (!FailingCommand->getCreator().hasGoodDiagnostics() || CommandRes != 1) {
2006 OS << getClangToolFullVersion("flang-new") << '\n';
2018 if (TC.isThreadModelSupported(A->getValue()))
2019 OS << "Thread model: " << A->getValue();
2027 // Print the build config if it's non-default.
2038 /// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
2050 // Print out all options that start with a given argument. This is used for
2057 // Make sure that Flang-only options don't pollute the Clang output
2058 // TODO: Make sure that Clang-only options don't pollute Flang output
2062 // Distinguish "--autocomplete=-someflag" and "--autocomplete=-someflag,"
2067 // Parse PassedFlags by "," as all the command-line flags are passed to this
2076 // We want to show cc1-only options only when clang is invoked with -cc1 or
2077 // -Xclang.
2078 if (llvm::is_contained(Flags, "-Xclang") || llvm::is_contained(Flags, "-cc1"))
2083 Cur = Flags.at(Flags.size() - 1);
2086 Prev = Flags.at(Flags.size() - 2);
2094 // list all possible flags. If there was no value completion and the user
2106 // If the flag is in the form of "--autocomplete=-foo",
2107 // we were requested to print out all option names that start with "-foo".
2108 // For example, "--autocomplete=-fsyn" is expanded to "-fsyntax-only".
2113 // We have to query the -W flags manually as they're not in the OptTable.
2123 // case-insensitive sorting for consistency with the -help option
2124 // which prints out options in the case-insensitive alphabetical order.
2135 // The order these options are handled in gcc is all over the place, but we
2144 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
2162 // Follow gcc behavior and use stdout for --version and stderr for -v.
2198 // Print -B and COMPILER_PATH.
2253 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
2258 StringRef ProgName = A->getValue();
2269 StringRef PassedFlags = A->getValue();
2352 // Display an action graph human-readably. Action A is the "sink" node
2353 // and latest-occuring action. Traversal is in pre-order, visiting the
2354 // inputs to each action before printing the action itself.
2364 auto getSibIndent = [](int K) -> Twine {
2370 os << Action::getClassName(A->getKind()) << ", ";
2372 os << "\"" << IA->getInputArg().getValue() << "\"";
2374 os << '"' << BIA->getArchName() << '"' << ", {"
2375 << PrintActions1(C, *BIA->input_begin(), Ids, SibIndent, SibKind) << "}";
2378 OA->doOnEachDependence(
2383 // "cuda-device" (nvptx64-nvidia-cuda:sm_20) {#ID}, "cuda-device"
2384 // (nvptx64-nvidia-cuda:sm_35) {#ID}
2388 os << A->getOffloadingKindPrefix();
2390 os << TC->getTriple().normalize();
2400 const ActionList *AL = &A->getInputs();
2402 if (AL->size()) {
2414 // Append offload info for all options other than the offloading action
2415 // itself (e.g. (cuda-device, sm_20) or (cuda-host)).
2419 auto S = A->getOffloadingKindPrefix();
2422 if (A->getOffloadingArch())
2423 offload_os << ", " << A->getOffloadingArch();
2428 auto getSelfIndent = [](int K) -> Twine {
2429 return (K == HeadSibAction) ? "+- " : (K == OtherSibAction) ? "|- " : "";
2435 << types::getTypeName(A->getType()) << offload_os.str() << "\n";
2441 // For example "clang -c file1.c file2.c" is composed of two subgraphs.
2455 return llvm::any_of(A->inputs(), ContainsCompileOrAssembleAction);
2468 if (A->getOption().matches(options::OPT_arch)) {
2472 tools::darwin::getArchTypeForMachOArchName(A->getValue());
2474 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
2478 A->claim();
2479 if (ArchNames.insert(A->getValue()).second)
2480 Archs.push_back(A->getValue());
2485 // the architecture (to the default) so that -Xarch_ is handled correctly.
2499 // -save-temps. Compatibility wins for now.
2501 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
2503 << types::getTypeName(Act->getType());
2505 ActionList Inputs;
2507 Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i]));
2510 // so that -Xarch_ gets overwritten.
2511 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
2512 Actions.append(Inputs.begin(), Inputs.end());
2514 Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType()));
2518 bool enablesDebugInfo = A && !A->getOption().matches(options::OPT_g0) &&
2519 !A->getOption().matches(options::OPT_gstabs);
2527 if (Act->getType() == types::TY_Image) {
2528 ActionList Inputs;
2529 Inputs.push_back(Actions.back());
2532 C.MakeAction<DsymutilJobAction>(Inputs, types::TY_dSYM));
2552 if (Value == "-")
2558 // allow the user to put "-fmodule-header -xc++-header vector" for example.
2568 // that all args that are not known options and that start with / are
2580 // In CL mode, don't error on apparently non-existent linker inputs, because
2584 // - `clang-cl main.cc ole32.lib` in a non-MSVC shell will make the driver
2587 // look in the registry might move into lld-link in the future so that
2588 // lld-link invocations in non-MSVC shells just work too.)
2589 // - `clang-cl ... /link ...` can pass arbitrary flags to the linker,
2593 // "'linker' input unused [-Wunused-command-line-argument]" warning instead
2599 // flag. (Users can use `-Wl,` or `/linker` to launder the flag past the
2602 // Don't do this for inputs that start with a '/', else we'd pass options
2605 // Emitting an error for linker inputs can also cause incorrect diagnostics
2607 // clang -fuse-ld=lld -Wl,--chroot,some/dir /file.o
2610 // `clang /GR-` compiles without error to see if the compiler is cl.exe,
2611 // so we can't downgrade diagnostics for `/GR-` from an error to a warning
2636 // Construct a the list of inputs and their types.
2638 InputList &Inputs) const {
2640 // Track the current user specified (-x) input. We also explicitly track the
2642 // actually use it, so we warn about unused -x arguments.
2650 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
2660 << Previous->getSpelling() << A->getSpelling();
2669 // Warn -x after last input file has no effect
2674 LastInputArg->getIndex() < LastXArg->getIndex())
2675 Diag(clang::diag::warn_drv_unused_x) << LastXArg->getValue();
2679 if (A->getOption().getKind() == Option::InputClass) {
2680 const char *Value = A->getValue();
2687 InputTypeArg->claim();
2690 if (memcmp(Value, "-", 2) == 0) {
2696 // If running with -E, treat as a C input (this changes the
2697 // builtin macros, for example). This may be overridden by -ObjC
2701 // spurious errors (e.g., no inputs).
2711 // clang-cl /E, or Object otherwise.
2739 // If running with -fthinlto-index=, extensions that normally identify
2746 // -ObjC and -ObjC++ override the default language, but only for "source
2760 // C headers by default - we know we are in C++ mode and we do not
2767 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
2776 InputTypeArg->claim();
2785 Inputs.push_back(std::make_pair(Ty, A));
2787 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
2788 StringRef Value = A->getValue();
2791 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
2792 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
2794 A->claim();
2795 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
2796 StringRef Value = A->getValue();
2799 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
2800 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
2802 A->claim();
2803 } else if (A->getOption().hasFlag(options::LinkerInput)) {
2806 Inputs.push_back(std::make_pair(types::TY_Object, A));
2808 } else if (A->getOption().matches(options::OPT_x)) {
2810 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
2811 A->claim();
2813 // Follow gcc behavior and treat as linker input for invalid -x
2817 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
2821 // If the user has put -fmodule-header{,=} then we treat C++ headers as
2822 // header unit inputs. So we 'promote' -xc++-header appropriately.
2825 } else if (A->getOption().getID() == options::OPT_U) {
2826 assert(A->getNumValues() == 1 && "The /U option has one value.");
2827 StringRef Val = A->getValue(0);
2835 if (CCCIsCPP() && Inputs.empty()) {
2838 Arg *A = MakeInputArg(Args, Opts, "-");
2839 Inputs.push_back(std::make_pair(types::TY_C, A));
2885 /// The inputs associated with this builder.
2886 const Driver::InputList &Inputs;
2893 const Driver::InputList &Inputs,
2895 : C(C), Args(Args), Inputs(Inputs),
2899 /// Fill up the array \a DA with all the device dependences that should be
2948 /// Flags to signal if the user requested host-only or device-only
2979 /// Flag for -fgpu-rdc.
2986 /// '-fuse-cuid='.
2990 /// Compilation unit ID specified by option '-cuid='.
2995 const Driver::InputList &Inputs,
2997 : DeviceActionBuilder(C, Args, Inputs, OFKind) {
3006 // to trigger the creation of all the CUDA device actions.
3009 // architecture. If we are in host-only mode we return 'success' so that
3017 if (!(IA->getType() == types::TY_CUDA ||
3018 IA->getType() == types::TY_HIP ||
3019 IA->getType() == types::TY_PP_HIP)) {
3031 // Replicate inputs for each GPU architecture.
3032 auto Ty = IA->getType() == types::TY_HIP ? types::TY_HIP_DEVICE
3043 llvm::sys::fs::real_path(IA->getInputArg().getValue(), RealPath,
3047 if (A->getOption().matches(options::OPT_INPUT))
3049 Hasher.update(A->getAsString(Args));
3055 IA->setId(CUID);
3059 C.MakeAction<InputAction>(IA->getInputArg(), Ty, IA->getId()));
3068 // If -fgpu-rdc is disabled, should not unbundle since there is no
3070 if (UA->getType() == types::TY_Object && !Relocatable)
3074 auto *IA = cast<InputAction>(UA->getInputs().back());
3075 std::string FileName = IA->getInputArg().getAsString(Args);
3082 if (IA->getType() == types::TY_Object &&
3092 UA->registerDependentActionInfo(ToolChains[0], Arch,
3107 AL.push_back(C.MakeAction<OffloadAction>(Dep, A->getType()));
3157 if (HostTC->getTriple().isNVPTX() ||
3158 HostTC->getTriple().getArch() == llvm::Triple::amdgcn) {
3161 // asserts that assume device-side compilation.
3163 << HostTC->getTriple().getArchName();
3177 StringRef UseCUIDStr = A->getValue();
3185 << A->getAsString(Args) << UseCUIDStr;
3191 // --offload and --offload-arch options are mutually exclusive.
3195 C.getDriver().Diag(diag::err_opt_not_valid_with_opt) << "--offload-arch"
3196 << "--offload";
3199 // Collect all offload arch parameters, removing duplicates.
3203 if (!(A->getOption().matches(options::OPT_offload_arch_EQ) ||
3204 A->getOption().matches(options::OPT_no_offload_arch_EQ)))
3206 A->claim();
3208 for (StringRef ArchStr : llvm::split(A->getValue(), ",")) {
3209 if (A->getOption().matches(options::OPT_no_offload_arch_EQ) &&
3210 ArchStr == "all") {
3214 auto GPUsOrErr = ToolChains.front()->getSystemGPUArchs(Args);
3218 << llvm::toString(GPUsOrErr.takeError()) << "--offload-arch";
3229 } else if (A->getOption().matches(options::OPT_offload_arch_EQ))
3231 else if (A->getOption().matches(options::OPT_no_offload_arch_EQ))
3242 << ConflictingArchs->first << ConflictingArchs->second;
3253 // suboptimally, on all newer GPUs.
3255 if (ToolChains.front()->getTriple().isSPIRV()) {
3256 if (ToolChains.front()->getTriple().getVendor() == llvm::Triple::AMD)
3274 const Driver::InputList &Inputs)
3275 : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_Cuda) {
3309 "Not expecting CUDA actions in host-only compilation.");
3316 // device-only mode.
3339 // device-only mode.
3345 assert(AssembleAction->getType() == types::TY_Object);
3346 assert(AssembleAction->getInputs().size() == 1);
3348 Action *BackendAction = AssembleAction->getInputs()[0];
3349 assert(BackendAction->getType() == types::TY_PP_Asm);
3355 C.MakeAction<OffloadAction>(DDep, A->getType()));
3377 // We avoid creating host action in device-only mode.
3382 // top-level action.
3400 /// The linker inputs obtained for each device arch.
3403 // BundleOutput needs to be tri-value: None, true, or false.
3404 // Bundle code objects except --no-gpu-output is specified for device
3406 // --gpu-bundle-output is specified for device only compilation.
3412 const Driver::InputList &Inputs)
3413 : CudaActionBuilderBase(C, Args, Inputs, Action::OFK_HIP) {
3425 << "-fhip-emit-relocatable"
3426 << "-fgpu-rdc";
3431 << "-fhip-emit-relocatable"
3432 << "--cuda-device-only";
3477 // non-relocatable device code, where we generate fat binary for device
3486 "Not expecting HIP actions in host-only compilation.");
3495 // a fat binary containing all the code objects for different GPU's.
3512 if (ToolChains.front()->getTriple().isSPIRV()) {
3513 // Emit LLVM bitcode for SPIR-V targets. SPIR-V device tool chain
3514 // (HIPSPVToolChain) runs post-link LLVM IR passes.
3544 DDep, CudaDeviceActions[I]->getType());
3577 LI->push_back(A);
3599 DDep, CudaDeviceActions[I]->getType());
3618 "Linker inputs and GPU arch list sizes do not match.");
3631 // Linking all inputs for the current GPU arch.
3632 // LI contains all the inputs for the linker.
3637 DeviceLinkDeps, DeviceLinkAction->getType()));
3648 // Create a host object from all the device images by embedding them
3649 // in a fat binary for mixed host-device compilation. For device-only
3660 C.MakeAction<OffloadAction>(DDeps, TopDeviceLinkAction->getType()));
3678 /// Flag set to true if all valid builders allow file bundling/unbundling.
3683 const Driver::InputList &Inputs)
3690 SpecializedBuilders.push_back(new CudaActionBuilder(C, Args, Inputs));
3693 SpecializedBuilders.push_back(new HIPActionBuilder(C, Args, Inputs));
3699 // Initialize all the builders, keeping track of errors. If all valid
3704 IsValid = IsValid && !SB->initialize();
3707 if (SB->isValid()) {
3709 if (SB->canUseBundlerUnbundler())
3751 // Check if all the programming models agree we should not emit the host
3757 if (!SB->isValid()) {
3762 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
3773 OffloadKind |= SB->getAssociatedOffloadKind();
3776 // If all builders agree that the host object should be ignored, just return
3804 // input action of non-source file, we replace the host action by the
3810 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
3811 (!types::isSrcFile(HostAction->getType()) ||
3812 HostAction->getType() == types::TY_PP_HIP)) {
3815 UnbundlingHostAction->registerDependentActionInfo(
3827 if (!SB->isValid())
3830 auto RetCode = SB->addDeviceDependences(HostAction);
3840 OffloadKind |= SB->getAssociatedOffloadKind();
3846 HostAction = UA->getInputs().back();
3862 if (!SB->isValid())
3864 SB->appendTopLevelActions(OffloadAL);
3872 HostAction->getType() != types::TY_Nothing && !OffloadAL.empty()) {
3888 HostAction->propagateHostOffloadInfo(InputArgToOffloadKindMap[InputArg],
3895 if (!SB->isValid())
3897 SB->appendLinkDeviceActions(AL);
3911 if (!SB->isValid())
3913 HA = SB->appendLinkHostActions(DeviceAL);
3917 HA->propagateHostOffloadInfo(SB->getAssociatedOffloadKind(),
3925 /// the host action all the offload kinds used in the current compilation. The
3928 // Add all the dependences from the device linking actions.
3931 if (!SB->isValid())
3934 SB->appendLinkDependences(DDeps);
3937 // Calculate all the offload kinds used in the current compilation.
3945 // Set all the active offloading kinds to the link action. Given that it
3946 // is a link action it is assumed to depend on all actions generated so
3948 HostAction->setHostOffloadInfo(ActiveOffloadKinds,
3952 for (auto *A : HostAction->inputs()) {
3956 auto OFKLoc = InputArgToOffloadKindMap.find(ArgLoc->second);
3959 A->propagateHostOffloadInfo(OFKLoc->second, /*BoundArch=*/nullptr);
3964 // Create the offload action with all dependences. When an offload action
3976 const InputList &Inputs,
3982 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
3988 if (YcArg && Inputs.size() > 1) {
4011 // If -dumpdir is not specified, give a default prefix derived from the link
4012 // output filename. For example, `clang -g -gsplit-dwarf a.c -o x` passes
4013 // `-dumpdir x-` to cc1. If -o is unspecified, use
4020 (FinalOutput ? FinalOutput->getValue()
4022 "-"));
4023 Arg->claim();
4029 // If only preprocessing or /Y- is used, all pch handling is disabled.
4030 // Rather than check for it everywhere, just remove clang-cl pch-related
4039 for (auto &I : Inputs) {
4050 if (InputArg->isClaimed())
4054 InputArg->claim();
4056 // Suppress all unused style warnings with -Qunused-arguments
4061 // by a command-line argument with a corresponding Arg.
4064 << InputArg->getAsString(Args) << getPhaseName(InitialPhase);
4065 // Special case '-E' warning on a previously preprocessed file to make
4074 << InputArg->getAsString(Args) << !!FinalPhaseArg
4075 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
4078 << InputArg->getAsString(Args) << getPhaseName(InitialPhase)
4080 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
4113 const InputList &Inputs, ActionList &Actions) const {
4116 if (!SuppressMissingInputWarning && Inputs.empty()) {
4123 StringRef V = A->getValue();
4124 if (Inputs.size() > 1 && !V.empty() &&
4126 // Check whether /Fo tries to name an output file for multiple inputs.
4128 << A->getSpelling() << V;
4135 StringRef V = A->getValue();
4136 if (Inputs.size() > 1 && !V.empty() &&
4138 // Check whether /Fa tries to name an asm file for multiple inputs.
4140 << A->getSpelling() << V;
4147 if (A->getValue()[0] == '\0') {
4149 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
4154 handleArguments(C, Args, Inputs, Actions);
4164 ? std::make_unique<OffloadingActionBuilder>(C, Args, Inputs)
4172 for (auto &I : Inputs) {
4188 if (OffloadBuilder->addHostDependenceToDeviceActions(Current, InputArg))
4195 Current = OffloadBuilder->addDeviceDependencesToHostAction(
4200 // Queue linker inputs.
4216 // Queue merger inputs.
4225 ExtractAPIAction->addHeaderInput(Current);
4230 // FIXME: Should we include any prior module file outputs as inputs of
4251 else if (OffloadBuilder->addHostDependenceToDeviceActions(Current,
4255 if (Current->getType() == types::TY_Nothing)
4265 OffloadBuilder->appendTopLevelActions(Actions, Current, InputArg);
4267 Current->propagateHostOffloadInfo(C.getActiveOffloadKinds(),
4277 OffloadBuilder->appendDeviceLinkActions(Actions);
4282 if (Action *Wrapper = OffloadBuilder->makeHostLinkAction())
4291 LA->propagateHostOffloadInfo(C.getActiveOffloadKinds(),
4297 LA = OffloadBuilder->processHostLinkAction(LA);
4313 for (auto &I : Inputs) {
4332 // Only IfsMerge (llvm-ifs) can handle .o files by looking for ifs
4365 // If --print-supported-cpus, -mcpu=? or -mtune=? is specified, build a
4368 // If either --print-supported-extensions or --print-enabled-extensions is
4377 << "--print-supported-extensions";
4384 << "--print-enabled-extensions";
4388 // Use the -mcpu=? flag as the dummy input to cc1.
4393 for (auto &I : Inputs)
4394 I.second->claim();
4398 // Call validator for dxil when -Vd not in Args.
4410 // Claim ignored clang-cl options.
4478 // --offload and --offload-arch options are mutually exclusive.
4483 << "--offload"
4485 ? "--offload-arch"
4486 : "--no-offload-arch");
4494 // Extract any '--[no-]offload-arch' arguments intended for this toolchain.
4496 if (Arg->getOption().matches(options::OPT_Xopenmp_target_EQ) &&
4497 ToolChain::getOpenMPTriple(Arg->getValue(0)) == TC->getTriple()) {
4498 Arg->claim();
4499 unsigned Index = Args.getBaseArgs().MakeIndex(Arg->getValue(1));
4506 if (Arg->getOption().matches(options::OPT_offload_arch_EQ)) {
4507 for (StringRef Arch : llvm::split(Arg->getValue(), ",")) {
4509 auto GPUsOrErr = TC->getSystemGPUArchs(Args);
4514 TC->getDriver().Diag(diag::err_drv_undetermined_gpu_arch)
4515 << llvm::Triple::getArchTypeName(TC->getArch())
4516 << llvm::toString(GPUsOrErr.takeError()) << "--offload-arch";
4523 TC->getTriple(), SuppressError));
4527 C, Args, Arch, TC->getTriple(), SuppressError);
4533 } else if (Arg->getOption().matches(options::OPT_no_offload_arch_EQ)) {
4534 for (StringRef Arch : llvm::split(Arg->getValue(), ",")) {
4535 if (Arch == "all") {
4539 C, Args, Arch, TC->getTriple(), SuppressError);
4549 getConflictOffloadArchCombination(Archs, TC->getTriple())) {
4551 << ConflictingArchs->first << ConflictingArchs->second;
4598 ToolChains.push_back(TI->second);
4611 // Get the product of all bound architectures and toolchains.
4637 if (A->getType() == types::TY_Nothing)
4641 A->propagateDeviceOffloadInfo(Kind, TCAndArch->second.data(),
4642 TCAndArch->first);
4647 HostAction->getType() != types::TY_Nothing) {
4651 HostAction->setCannotBeCollapsedWithNextDependentAction();
4654 TCAndArch->second.data(), Kind);
4656 DDep.add(*A, *TCAndArch->first, TCAndArch->second.data(), Kind);
4664 // Compiling HIP in non-RDC mode requires linking each action individually.
4666 if ((A->getType() != types::TY_Object &&
4667 A->getType() != types::TY_LTO_BC) ||
4677 DDeps.add(*A, *TCAndArch->first, TCAndArch->second.data(), Kind);
4679 DDep.add(*A, *TCAndArch->first, TCAndArch->second.data(), Kind);
4681 // Compiling CUDA in non-RDC mode uses the PTX output if available.
4682 for (Action *Input : A->getInputs())
4683 if (Kind == Action::OFK_Cuda && A->getType() == types::TY_Object &&
4686 DDep.add(*Input, *TCAndArch->first, TCAndArch->second.data(), Kind);
4687 OffloadActions.push_back(C.MakeAction<OffloadAction>(DDep, A->getType()));
4693 // HIP code in non-RDC mode will bundle the output if it invoked the linker.
4700 [](Action *A) { return A->getType() != types::TY_Image; });
4702 // All kinds exit now in device-only mode except for non-RDC mode HIP.
4712 // If we are not in RDC-mode we just emit the final CUDA fatbinary for
4721 // If we are not in RDC-mode we just emit the final HIP fatbinary for each
4728 // Package all the offloading actions into a single output that can be
4736 // HIP wants '--offload-device-only' to create a fatbinary by default.
4743 return A->getType() == types::TY_Nothing;
4756 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
4759 if (Phase == phases::Assemble && Input->getType() != types::TY_PP_Asm)
4770 // -M and -MM specify the dependency file name by altering the output type,
4771 // -if -MD and -MMD are not specified.
4776 OutputTy = Input->getType();
4797 // With 'fexperimental-modules-reduced-bmi', we don't want to run the
4798 // precompile phase unless the user specified '--precompile'. In the case
4799 // the '--precompile' flag is enabled, we will try to emit the reduced BMI
4805 types::ID OutputTy = getPrecompiledType(Input->getType());
4809 // If we're given a module name, precompile header file inputs as a
4814 ModName = A->getValue();
4869 (((Input->getOffloadingToolChain() &&
4870 Input->getOffloadingToolChain()->getTriple().isAMDGPU()) ||
4900 // It is an error to provide a -o option if we are making multiple output
4909 // and -c is passed, we still want to be able to generate a .ifs file while
4913 // OffloadClass of type TY_Nothing: device-only output will place many outputs
4914 // into a single offloading action. We should count all inputs to the action
4915 // as outputs. Also ignore device-only outputs if we're compiling with
4916 // -fsyntax-only.
4921 if (A->getType() != types::TY_Nothing &&
4922 A->getType() != types::TY_DX_CONTAINER &&
4923 !(A->getKind() == Action::IfsMergeJobClass ||
4924 (A->getType() == clang::driver::types::TY_IFS_CPP &&
4925 A->getKind() == clang::driver::Action::CompileJobClass &&
4927 (A->getKind() == Action::BindArchClass && A->getInputs().size() &&
4928 A->getInputs().front()->getKind() == Action::IfsMergeJobClass)))
4930 else if (A->getKind() == Action::OffloadClass &&
4931 A->getType() == types::TY_Nothing &&
4933 NumOutputs += A->size();
4948 if (A->getOption().matches(options::OPT_arch))
4949 ArchNames.insert(A->getValue());
4955 // -arch_multiple and -final_output <final image name>. Unfortunately, this
4963 LinkingOutput = FinalOutput->getValue();
4976 // If we have more than one job, then disable integrated-cc1 for now. Do this
4991 LinkingOutput = FinalOutput->getValue();
5003 << format("%.3f", ProcStat->TotalTime.count() / 1000.) << " ms"
5005 << format("%.3f", ProcStat->UserTime.count() / 1000.) << " ms"
5006 << ", mem=" << ProcStat->PeakMemory << " Kb\n";
5015 Out << ',' << ProcStat->TotalTime.count() << ','
5016 << ProcStat->UserTime.count() << ',' << ProcStat->PeakMemory
5038 // If the user passed -Qunused-arguments or there were errors, don't warn
5044 // Claim -fdriver-only here.
5046 // Claim -### here.
5049 // Claim --driver-mode, --rsp-quoting, it was handled earlier.
5063 if (!A->isClaimed()) {
5064 if (A->getOption().hasFlag(options::NoArgumentUnused))
5069 const Option &Opt = A->getOption();
5074 if (AA->isClaimed()) {
5084 // In clang-cl, don't mention unknown arguments here since they have
5086 if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN)) {
5087 if (A->getOption().hasFlag(options::TargetSpecific) &&
5088 !A->isIgnoredTargetSpecific() && !HasAssembleJob &&
5089 // When for example -### or -v is used
5095 << A->getSpelling() << getTargetTriple();
5098 << A->getAsString(C.getArgs());
5121 /// Set to true if save-temps and embed-bitcode functionalities are active.
5128 const JobAction *getPrevDependentAction(const ActionList &Inputs,
5132 if (Inputs.size() != 1)
5135 Action *CurAction = *Inputs.begin();
5137 !CurAction->isCollapsingWithNextDependentActionLegal())
5147 if (OA->hasSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)) {
5149 OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true);
5151 !CurAction->isCollapsingWithNextDependentActionLegal())
5156 } else if (OA->hasHostDependence()) {
5157 CurAction = OA->getHostDependence();
5159 !CurAction->isCollapsingWithNextDependentActionLegal())
5208 /// legal, and if so they update the inputs \a Inputs and the offload action
5213 /// - Assemble + Backend + Compile;
5214 /// - Assemble + Backend ;
5215 /// - Backend + Compile.
5218 ActionList &Inputs,
5235 bool OutputIsLLVM = types::isLLVMIR(ActionInfo[0].JA->getType());
5236 if (!T->hasIntegratedBackend() && !(OutputIsLLVM && T->canEmitIR()))
5239 // When using -fembed-bitcode, it is required to have the same tool (clang)
5247 if (!T->hasIntegratedAssembler())
5250 Inputs = CJ->getInputs();
5256 ActionList &Inputs,
5270 if (!T->hasIntegratedAssembler())
5273 Inputs = BJ->getInputs();
5279 ActionList &Inputs,
5291 // -save-temps. I.e. there is no need for a separate compile job just to
5295 if (ActionInfo[i].JA->getType() != types::TY_LLVM_BC &&
5296 ActionInfo[i].JA->getType() != types::TY_LTO_BC) {
5310 bool OutputIsLLVM = types::isLLVMIR(ActionInfo[0].JA->getType());
5311 if (!T->hasIntegratedBackend() && !(OutputIsLLVM && T->canEmitIR()))
5314 if (T->canEmitIR() && ((SaveTemps && !InputIsBitcode) || EmbedBitcode))
5317 Inputs = CJ->getInputs();
5323 /// Updates the inputs if the obtained tool supports combining with
5327 void combineWithPreprocessor(const Tool *T, ActionList &Inputs,
5329 if (!T || !canCollapsePreprocessorAction() || !T->hasIntegratedCPP())
5335 for (Action *A : Inputs) {
5343 // current input to preprocessor inputs.
5346 NewInputs.append(PJ->input_begin(), PJ->input_end());
5348 Inputs = NewInputs;
5357 IsHostSelector = BaseAction->getOffloadingDeviceKind() == Action::OFK_None;
5361 /// handle the combination of actions. The pointer to the current inputs \a
5362 /// Inputs and the list of offload actions \a CollapsedOffloadActions
5366 const Tool *getTool(ActionList &Inputs,
5383 getPrevDependentAction(CurAction->getInputs(), AI.SavedOffloadAction);
5390 // Attempt to combine actions. If all combining attempts failed, just return
5395 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
5398 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
5400 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
5402 Inputs = BaseAction->getInputs();
5406 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
5413 /// is not necessarily represented in the toolchain's triple -- for example,
5414 /// armv7 and armv7s both map to the same triple -- so we need both in our map.
5420 std::string TriplePlusArch = TC->getTriple().normalize();
5422 TriplePlusArch += "-";
5425 TriplePlusArch += "-";
5440 return CachedResult->second;
5457 if (A->getOption().matches(options::OPT_ftime_trace_EQ)) {
5458 Path = A->getValue();
5468 Path = DumpDir->getValue();
5500 // Host Action 1 -> OffloadAction -> Host Action 2
5503 // Device Action 1 -> OffloadAction -> Device Action 2
5508 // Host Action 1 ---> OffloadAction -> Host Action 2
5513 // Device Action 1 ---> OffloadAction -> Device Action 2
5522 if (OA->hasSingleDeviceDependence() || !OA->hasHostDependence()) {
5524 OA->doOnEachDeviceDependence([&](Action *DepA, const ToolChain *DepTC,
5529 DepA->getOffloadingDeviceKind()));
5537 // dependence. The dependences can't therefore be a top-level action.
5538 OA->doOnEachDependence(
5544 DepA->getOffloadingDeviceKind()));
5548 ? OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)
5549 : OA->getHostDependence();
5554 OA->getHostDependence(),
5557 InputInfoList Inputs = CachedResults[ActionTC];
5558 Inputs.append(OffloadDependencesInputInfo);
5559 return Inputs;
5566 const Arg &Input = IA->getInputArg();
5577 StringRef ArchName = BAA->getArchName();
5586 return BuildJobsForAction(C, *BAA->input_begin(), TC, ArchName, AtTopLevel,
5592 ActionList Inputs = A->getInputs();
5599 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
5605 // need to build jobs for host/device-side inputs it may have held.
5607 cast<OffloadAction>(OA)->doOnEachDependence(
5613 DepA->getOffloadingDeviceKind()));
5618 for (const Action *Input : Inputs) {
5619 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
5626 CachedResults, A->getOffloadingDeviceKind()));
5640 if (JA->getType() == types::TY_dSYM)
5650 const ToolChain &ToolTC = T->getToolChain();
5652 C.getArgsForToolChain(TC, BoundArch, A->getOffloadingDeviceKind());
5666 // If we have an unbundling job, we need to create results for all the
5669 for (auto &UI : UA->getDependentActionsInfo()) {
5679 UI.DependentToolChain->getTriple().normalize(),
5708 // Now that we have all the results generated, select the one that should be
5715 } else if (JA->getType() == types::TY_Nothing)
5718 // We only have to generate a prefix for the host if this is not a top-level
5721 A->getOffloadingDeviceKind(), TC->getTriple().normalize(),
5723 !(A->getOffloadingHostActiveKinds() == Action::OFK_None ||
5729 if (T->canEmitIR() && OffloadingPrefix.empty())
5734 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
5735 << " - \"" << T->getName() << "\", inputs: [";
5754 T->ConstructJob(
5756 C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()),
5759 T->ConstructJobMultipleOutputs(
5761 C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()),
5824 ? std::string(A->getValue())
5831 const char *Middle = !Suffix.empty() ? "-%%%%%%." : "-%%%%%%";
5842 Twine(Prefix) + "-" + BoundArch + "." + Suffix);
5845 GetTemporaryPath((Twine(Prefix) + "-" + BoundArch).str(), Suffix);
5856 // with the `-fmodule-output` option or `-fmodule-output=` option specified.
5858 // - If `-fmodule-output=` is specfied, then the module file is
5860 // - Otherwise if the output object file of the module unit is specified, the
5863 // the corresponding suffix. This requires both `-o` and `-c` are specified.
5864 // - Otherwise, the output path of the module file will be the same with the
5894 return C.addResultFile(FinalOutput->getValue(), &JA);
5903 NameArg = A->getValue();
5911 return "-";
5916 return "-";
5956 return "-";
5965 // `-fmodule-output`.
5980 // The non-offloading toolchain on Darwin requires deterministic input
5998 ExternalPath += C.getArgs().getLastArg(options::OPT_dsym_dir)->getValue();
6000 // darwin-dsymutil.c) demonstrate that posix style paths are acceptable
6020 ->getValue();
6030 ->getValue();
6035 // clang-cl uses BaseName for the executable name.
6040 // HIP image for device compilation with -fno-gpu-rdc is per compilation
6052 Output += "-";
6066 ->getValue();
6072 assert(Suffix && "All types used for output should have a suffix.");
6080 Suffixed += "-";
6083 // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for
6088 // The relocatable compilation in HIP and OpenMP implies -emit-llvm.
6097 TC->getTriple().isAMDGPU()));
6108 // Prepend object file path if -save-temps=obj
6112 SmallString<128> TempPath(FinalOutput->getValue());
6154 -> std::optional<std::string> {
6155 // Respect a limited subset of the '-Bprefix' functionality in GCC by
6204 Names.emplace_back((TargetTriple + "-" + Tool).str());
6220 // Respect a limited subset of the '-Bprefix' functionality in GCC by
6241 // E.g. <triple>-gcc on the path will be found instead
6264 auto evaluate = [&](const char *library) -> std::optional<std::string> {
6268 // to look at the command-line arguments for the proper json. These
6276 // return "libc++.modules-asan.json";
6331 Output = FpArg->getValue();
6339 Output = YcArg->getValue();
6571 !types::isAcceptedByClang((*JA.input_begin())->getType()))
6586 !types::isAcceptedByFlang((*JA.input_begin())->getType()))
6604 /// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
6607 /// \return True if the entire string was parsed (9.2), or all groups were
6687 return "clang-cpp";
6689 return "clang-cl";
6693 return "clang-dxc";
6704 // -fsave-optimization-record enables it.
6709 // -fsave-optimization-record=<format> enables it as well.
6714 // -foptimization-record-file alone enables it too.
6719 // -foptimization-record-passes alone enables it too.
6749 // clang-cl or cl, or --driver-mode=cl is on the command line. The normal
6751 // have to manually search for a --driver-mode=cl argument the hard way.
6752 // Finally, our -cc1 tools don't care which tokenization mode we use because
6756 if (strcmp(F, "--rsp-quoting=posix") == 0)
6758 else if (strcmp(F, "--rsp-quoting=windows") == 0)
6763 // files end-of-lines. We only use this for the /LINK driver argument with
6764 // clang-cl.exe on Windows.
6773 if (MarkEOLs && Args.size() > 1 && StringRef(Args[1]).starts_with("-cc1"))
6784 // If -cc1 came from a response file, remove the EOL sentinels.
6787 if (FirstArg != Args.end() && StringRef(*FirstArg).starts_with("-cc1")) {
6788 // If -cc1 came from a response file, remove the EOL sentinels.
6791 Args.resize(newEnd - Args.begin());
6799 return SavedStrings.insert(S).first->getKeyData();
6817 /// 'xOPTION': Removes all instances of the literal argument OPTION.
6819 /// 'XOPTION': Removes all instances of the literal argument OPTION,
6822 /// 'Ox': Removes all flags matching 'O' or 'O[sz0-9]' and adds 'Ox'
6825 /// \param OS - The stream to write edit information to.
6826 /// \param Args - The vector of command line arguments.
6827 /// \param Edit - The override command to perform.
6828 /// \param SavedStrings - Set to use for storing string representations.
6844 Edit.slice(2, Edit.size() - 1).contains('/')) {
6847 ReplPattern = ReplPattern.slice(0, ReplPattern.size() - 1);
6850 // Ignore end-of-line response file markers
6879 // Ignore end-of-line response file markers
6882 if (A[0] == '-' && A[1] == 'O' &&
6891 Args.push_back(GetStableCStr(SavedStrings, '-' + Edit.str()));