blob: a1adb676a39dd346b93f930121f2bbb3d704a8be [file] [log] [blame]
Nick Lewyckye47c2452010-09-23 23:48:20 +00001//===--- Driver.cpp - Clang GCC Compatible Driver -------------------------===//
Daniel Dunbar544ecd12009-03-02 19:59:07 +00002//
3// The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9
Daniel Dunbar544ecd12009-03-02 19:59:07 +000010#include "clang/Driver/Driver.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000011#include "InputInfo.h"
12#include "ToolChains.h"
13#include "clang/Basic/Version.h"
Benjamin Kramerd45b2052015-10-07 15:48:01 +000014#include "clang/Basic/VirtualFileSystem.h"
Alp Toker1d257e12014-06-04 03:28:55 +000015#include "clang/Config/config.h"
Daniel Dunbar1688f1a2009-03-12 07:58:46 +000016#include "clang/Driver/Action.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000017#include "clang/Driver/Compilation.h"
Daniel Dunbarc0b3e952009-03-12 08:55:43 +000018#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000019#include "clang/Driver/Job.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000020#include "clang/Driver/Options.h"
Peter Collingbournea4ccff32015-02-20 20:30:56 +000021#include "clang/Driver/SanitizerArgs.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000022#include "clang/Driver/Tool.h"
23#include "clang/Driver/ToolChain.h"
Chris Lattnerce6c42f2011-03-23 04:04:01 +000024#include "llvm/ADT/ArrayRef.h"
Hans Wennborg6ddc6902013-07-27 00:23:45 +000025#include "llvm/ADT/STLExtras.h"
Justin Lebar62907612016-07-06 21:21:39 +000026#include "llvm/ADT/SmallSet.h"
Hans Wennborg23d26a32014-06-18 17:21:50 +000027#include "llvm/ADT/StringExtras.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000028#include "llvm/ADT/StringSet.h"
Hans Wennborg70850d82013-07-18 20:29:38 +000029#include "llvm/ADT/StringSwitch.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000030#include "llvm/Option/Arg.h"
31#include "llvm/Option/ArgList.h"
Chandler Carruth5553d0d2014-01-07 11:51:46 +000032#include "llvm/Option/OptSpecifier.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000033#include "llvm/Option/OptTable.h"
34#include "llvm/Option/Option.h"
David Blaikie79000202011-09-23 05:57:42 +000035#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf28df4c2010-12-17 21:22:22 +000036#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000037#include "llvm/Support/Path.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000038#include "llvm/Support/PrettyStackTrace.h"
Hans Wennborg23d26a32014-06-18 17:21:50 +000039#include "llvm/Support/Process.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000040#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000041#include "llvm/Support/raw_ostream.h"
Dylan Noblesmith4f4e7452012-02-02 00:40:14 +000042#include <map>
Ahmed Charlesdfca6f92014-03-09 11:36:40 +000043#include <memory>
Benjamin Kramercfeacf52016-05-27 14:27:13 +000044#include <utility>
Dylan Noblesmith86780e92012-02-01 14:25:28 +000045
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000046using namespace clang::driver;
Chris Lattnerada1c912009-03-26 05:56:24 +000047using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000048using namespace llvm::opt;
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000049
Reid Kleckner68eb60b2015-02-02 22:41:48 +000050Driver::Driver(StringRef ClangExecutable, StringRef DefaultTargetTriple,
Benjamin Kramerd45b2052015-10-07 15:48:01 +000051 DiagnosticsEngine &Diags,
52 IntrusiveRefCntPtr<vfs::FileSystem> VFS)
Benjamin Kramercfeacf52016-05-27 14:27:13 +000053 : Opts(createDriverOptTable()), Diags(Diags), VFS(std::move(VFS)),
54 Mode(GCCMode), SaveTemps(SaveTempsNone), BitcodeEmbed(EmbedNone),
55 LTOMode(LTOK_None), ClangExecutable(ClangExecutable),
Reid Kleckner68eb60b2015-02-02 22:41:48 +000056 SysRoot(DEFAULT_SYSROOT), UseStdLib(true),
Reid Kleckner68eb60b2015-02-02 22:41:48 +000057 DriverTitle("clang LLVM compiler"), CCPrintOptionsFilename(nullptr),
58 CCPrintHeadersFilename(nullptr), CCLogDiagnosticsFilename(nullptr),
59 CCCPrintBindings(false), CCPrintHeaders(false), CCLogDiagnostics(false),
Vedant Kumarf2030b92016-07-18 19:56:33 +000060 CCGenDiagnostics(false), DefaultTargetTriple(DefaultTargetTriple),
61 CCCGenericGCCName(""), CheckInputsExist(true), CCCUsePCH(true),
62 SuppressMissingInputWarning(false) {
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +000063
Benjamin Kramerd45b2052015-10-07 15:48:01 +000064 // Provide a sane fallback if no VFS is specified.
65 if (!this->VFS)
66 this->VFS = vfs::getRealFileSystem();
67
Sumanth Gundapaneni3a1592942015-03-03 20:43:12 +000068 Name = llvm::sys::path::filename(ClangExecutable);
Douglas Katzmana67e50c2015-06-26 15:47:46 +000069 Dir = llvm::sys::path::parent_path(ClangExecutable);
Benjamin Kramerf420dda2015-10-13 15:19:32 +000070 InstalledDir = Dir; // Provide a sensible default installed dir.
Bob Wilsona20a1da2013-03-23 05:17:59 +000071
72 // Compute the path to the resource directory.
73 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
74 SmallString<128> P(Dir);
Chandler Carruthfd3cc702014-12-29 12:09:08 +000075 if (ClangResourceDir != "") {
Bob Wilsona20a1da2013-03-23 05:17:59 +000076 llvm::sys::path::append(P, ClangResourceDir);
Chandler Carruthfd3cc702014-12-29 12:09:08 +000077 } else {
78 StringRef ClangLibdirSuffix(CLANG_LIBDIR_SUFFIX);
79 llvm::sys::path::append(P, "..", Twine("lib") + ClangLibdirSuffix, "clang",
80 CLANG_VERSION_STRING);
81 }
Bob Wilsona20a1da2013-03-23 05:17:59 +000082 ResourceDir = P.str();
Daniel Dunbar544ecd12009-03-02 19:59:07 +000083}
84
85Driver::~Driver() {
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000086 delete Opts;
Chandler Carruth2ad5de12012-01-25 11:01:57 +000087
Reid Kleckner588c9372014-02-19 23:44:52 +000088 llvm::DeleteContainerSeconds(ToolChains);
Daniel Dunbar544ecd12009-03-02 19:59:07 +000089}
90
Zachary Turneraff19c32016-08-12 17:47:52 +000091void Driver::ParseDriverMode(StringRef ProgramName,
92 ArrayRef<const char *> Args) {
93 auto Default = ToolChain::getTargetAndModeFromProgramName(ProgramName);
94 StringRef DefaultMode(Default.second);
95 setDriverModeFromOption(DefaultMode);
Hans Wennborg70850d82013-07-18 20:29:38 +000096
Douglas Katzman6bbffc42015-06-25 18:51:37 +000097 for (const char *ArgPtr : Args) {
Reid Kleckneraf5fd6a2014-08-22 19:29:30 +000098 // Ingore nullptrs, they are response file's EOL markers
Douglas Katzman6bbffc42015-06-25 18:51:37 +000099 if (ArgPtr == nullptr)
Reid Kleckneraf5fd6a2014-08-22 19:29:30 +0000100 continue;
Douglas Katzman6bbffc42015-06-25 18:51:37 +0000101 const StringRef Arg = ArgPtr;
Zachary Turneraff19c32016-08-12 17:47:52 +0000102 setDriverModeFromOption(Arg);
Hans Wennborg70850d82013-07-18 20:29:38 +0000103 }
104}
105
Zachary Turneraff19c32016-08-12 17:47:52 +0000106void Driver::setDriverModeFromOption(StringRef Opt) {
107 const std::string OptName =
108 getOpts().getOption(options::OPT_driver_mode).getPrefixedName();
109 if (!Opt.startswith(OptName))
110 return;
111 StringRef Value = Opt.drop_front(OptName.size());
112
113 const unsigned M = llvm::StringSwitch<unsigned>(Value)
114 .Case("gcc", GCCMode)
115 .Case("g++", GXXMode)
116 .Case("cpp", CPPMode)
117 .Case("cl", CLMode)
118 .Default(~0U);
119
120 if (M != ~0U)
121 Mode = static_cast<DriverMode>(M);
122 else
123 Diag(diag::err_drv_unsupported_option_argument) << OptName << Value;
124}
125
David Blaikie69a1d8c2015-06-22 22:07:27 +0000126InputArgList Driver::ParseArgStrings(ArrayRef<const char *> ArgStrings) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000127 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000128
129 unsigned IncludedFlagsBitmask;
130 unsigned ExcludedFlagsBitmask;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +0000131 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000132 getIncludeExcludeOptionFlagMasks();
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000133
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000134 unsigned MissingArgIndex, MissingArgCount;
David Blaikie69a1d8c2015-06-22 22:07:27 +0000135 InputArgList Args =
David Blaikie6d492ad2015-06-21 06:32:36 +0000136 getOpts().ParseArgs(ArgStrings, MissingArgIndex, MissingArgCount,
137 IncludedFlagsBitmask, ExcludedFlagsBitmask);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000138
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000139 // Check for missing argument error.
140 if (MissingArgCount)
141 Diag(clang::diag::err_drv_missing_argument)
David Blaikie69a1d8c2015-06-22 22:07:27 +0000142 << Args.getArgString(MissingArgIndex) << MissingArgCount;
Daniel Dunbar65229332009-03-13 11:38:42 +0000143
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000144 // Check for unsupported options.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000145 for (const Arg *A : Args) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000146 if (A->getOption().hasFlag(options::Unsupported)) {
David Blaikie69a1d8c2015-06-22 22:07:27 +0000147 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(Args);
Daniel Dunbard8500f32009-03-22 23:26:43 +0000148 continue;
149 }
Chad Rosierce975d92012-02-22 17:55:22 +0000150
151 // Warn about -mcpu= without an argument.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000152 if (A->getOption().matches(options::OPT_mcpu_EQ) && A->containsValue("")) {
David Blaikie69a1d8c2015-06-22 22:07:27 +0000153 Diag(clang::diag::warn_drv_empty_joined_argument) << A->getAsString(Args);
Chad Rosierce975d92012-02-22 17:55:22 +0000154 }
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000155 }
156
David Blaikie69a1d8c2015-06-22 22:07:27 +0000157 for (const Arg *A : Args.filtered(options::OPT_UNKNOWN))
Ehsan Akhgarid8518332016-01-25 21:14:52 +0000158 Diags.Report(IsCLMode() ? diag::warn_drv_unknown_argument_clang_cl :
159 diag::err_drv_unknown_argument)
160 << A->getAsString(Args);
Rafael Espindola8a2d4962013-09-23 23:55:25 +0000161
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000162 return Args;
163}
164
Chad Rosier7742b5d2011-07-27 23:36:45 +0000165// Determine which compilation mode we are in. We look for options which
166// affect the phase, starting with the earliest phases, and record which
167// option we used to determine the final phase.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000168phases::ID Driver::getFinalPhase(const DerivedArgList &DAL,
169 Arg **FinalPhaseArg) const {
Craig Topper92fc2df2014-05-17 16:56:41 +0000170 Arg *PhaseArg = nullptr;
Chad Rosier7742b5d2011-07-27 23:36:45 +0000171 phases::ID FinalPhase;
Eric Christopherf901e852011-08-17 22:59:59 +0000172
Hans Wennborge50cec32014-06-13 20:59:54 +0000173 // -{E,EP,P,M,MM} only run the preprocessor.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000174 if (CCCIsCPP() || (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
Hans Wennborge50cec32014-06-13 20:59:54 +0000175 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_EP)) ||
Hans Wennborge0053472013-12-20 18:40:46 +0000176 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM)) ||
177 (PhaseArg = DAL.getLastArg(options::OPT__SLASH_P))) {
Chad Rosier7742b5d2011-07-27 23:36:45 +0000178 FinalPhase = phases::Preprocess;
Eric Christopherf901e852011-08-17 22:59:59 +0000179
Bob Wilson23a55f12014-12-21 07:00:00 +0000180 // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
Chad Rosier7742b5d2011-07-27 23:36:45 +0000181 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +0000182 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
Ben Langmuir2cb4a782014-02-05 22:21:15 +0000183 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000184 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
Fariborz Jahanian73223bb2012-04-02 15:59:19 +0000185 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
Ted Kremenekf7639e12012-03-06 20:06:33 +0000186 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000187 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
Chad Rosier1aeb15a2012-03-06 23:14:35 +0000188 options::OPT__analyze_auto)) ||
Bob Wilson23a55f12014-12-21 07:00:00 +0000189 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
Chad Rosier7742b5d2011-07-27 23:36:45 +0000190 FinalPhase = phases::Compile;
191
Bob Wilson23a55f12014-12-21 07:00:00 +0000192 // -S only runs up to the backend.
193 } else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
194 FinalPhase = phases::Backend;
195
Artem Belevich4242f412015-07-28 21:01:21 +0000196 // -c compilation only runs up to the assembler.
197 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
Chad Rosier7742b5d2011-07-27 23:36:45 +0000198 FinalPhase = phases::Assemble;
199
200 // Otherwise do everything.
201 } else
202 FinalPhase = phases::Link;
203
204 if (FinalPhaseArg)
205 *FinalPhaseArg = PhaseArg;
206
207 return FinalPhase;
208}
209
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000210static Arg *MakeInputArg(DerivedArgList &Args, OptTable *Opts,
Hans Wennborged1d0722013-08-13 21:32:29 +0000211 StringRef Value) {
212 Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value,
213 Args.getBaseArgs().MakeIndex(Value), Value.data());
Hans Wennborg55362852014-05-02 22:55:30 +0000214 Args.AddSynthesizedArg(A);
Hans Wennborged1d0722013-08-13 21:32:29 +0000215 A->claim();
216 return A;
217}
218
Daniel Dunbar775d4062010-06-11 22:00:26 +0000219DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
220 DerivedArgList *DAL = new DerivedArgList(Args);
221
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000222 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
Nirav Daveb0bb6142015-11-24 16:07:21 +0000223 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000224 for (Arg *A : Args) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000225 // Unfortunately, we have to parse some forwarding options (-Xassembler,
226 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
227 // (assembler and preprocessor), or bypass a previous driver ('collect2').
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000228
229 // Rewrite linker options, to replace --no-demangle with a custom internal
230 // option.
231 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
232 A->getOption().matches(options::OPT_Xlinker)) &&
233 A->containsValue("--no-demangle")) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000234 // Add the rewritten no-demangle argument.
235 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
236
237 // Add the remaining values as Xlinker arguments.
Benjamin Kramer72e64312015-09-24 14:48:49 +0000238 for (StringRef Val : A->getValues())
Douglas Katzmana34b7bf2015-06-30 19:32:57 +0000239 if (Val != "--no-demangle")
240 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000241
242 continue;
243 }
244
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000245 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
246 // some build systems. We don't try to be complete here because we don't
247 // care to encourage this usage model.
248 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
Richard Smithbd55daf2012-11-01 04:30:05 +0000249 (A->getValue(0) == StringRef("-MD") ||
250 A->getValue(0) == StringRef("-MMD"))) {
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000251 // Rewrite to -MD/-MMD along with -MF.
Richard Smithbd55daf2012-11-01 04:30:05 +0000252 if (A->getValue(0) == StringRef("-MD"))
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000253 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
254 else
255 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
Michael J. Spencer70d85be2012-11-07 23:37:14 +0000256 if (A->getNumValues() == 2)
257 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
258 A->getValue(1));
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000259 continue;
260 }
261
Shantonu Senafeb03b2010-09-17 18:39:08 +0000262 // Rewrite reserved library names.
263 if (A->getOption().matches(options::OPT_l)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000264 StringRef Value = A->getValue();
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000265
Shantonu Senafeb03b2010-09-17 18:39:08 +0000266 // Rewrite unless -nostdlib is present.
Nirav Daveb0bb6142015-11-24 16:07:21 +0000267 if (!HasNostdlib && !HasNodefaultlib && Value == "stdc++") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000268 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000269 continue;
270 }
Shantonu Senafeb03b2010-09-17 18:39:08 +0000271
272 // Rewrite unconditionally.
273 if (Value == "cc_kext") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000274 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
Shantonu Senafeb03b2010-09-17 18:39:08 +0000275 continue;
276 }
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000277 }
278
Hans Wennborged1d0722013-08-13 21:32:29 +0000279 // Pick up inputs via the -- option.
280 if (A->getOption().matches(options::OPT__DASH_DASH)) {
281 A->claim();
Benjamin Kramer72e64312015-09-24 14:48:49 +0000282 for (StringRef Val : A->getValues())
Douglas Katzmana34b7bf2015-06-30 19:32:57 +0000283 DAL->append(MakeInputArg(*DAL, Opts, Val));
Hans Wennborged1d0722013-08-13 21:32:29 +0000284 continue;
285 }
286
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000287 DAL->append(A);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000288 }
Daniel Dunbar775d4062010-06-11 22:00:26 +0000289
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000290 // Enforce -static if -miamcu is present.
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000291 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false))
292 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000293
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000294// Add a default value of -mlinker-version=, if one was given and the user
295// didn't specify one.
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000296#if defined(HOST_LINK_VERSION)
Tim Northover018578c2015-06-12 19:21:35 +0000297 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
298 strlen(HOST_LINK_VERSION) > 0) {
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000299 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
300 HOST_LINK_VERSION);
Daniel Dunbarb613ffc2010-08-17 22:32:45 +0000301 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000302 }
303#endif
304
Daniel Dunbar775d4062010-06-11 22:00:26 +0000305 return DAL;
306}
307
Artem Belevich959e0542015-07-10 19:47:55 +0000308/// \brief Compute target triple from args.
309///
310/// This routine provides the logic to compute a target triple from various
311/// args passed to the driver and the default triple string.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000312static llvm::Triple computeTargetTriple(const Driver &D,
313 StringRef DefaultTargetTriple,
Artem Belevich959e0542015-07-10 19:47:55 +0000314 const ArgList &Args,
315 StringRef DarwinArchName = "") {
316 // FIXME: Already done in Compilation *Driver::BuildCompilation
317 if (const Arg *A = Args.getLastArg(options::OPT_target))
318 DefaultTargetTriple = A->getValue();
319
320 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
321
322 // Handle Apple-specific options available here.
323 if (Target.isOSBinFormatMachO()) {
324 // If an explict Darwin arch name is given, that trumps all.
325 if (!DarwinArchName.empty()) {
326 tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
327 return Target;
328 }
329
330 // Handle the Darwin '-arch' flag.
331 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
332 StringRef ArchName = A->getValue();
333 tools::darwin::setTripleTypeForMachOArchName(Target, ArchName);
334 }
335 }
336
337 // Handle pseudo-target flags '-mlittle-endian'/'-EL' and
338 // '-mbig-endian'/'-EB'.
339 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
340 options::OPT_mbig_endian)) {
341 if (A->getOption().matches(options::OPT_mlittle_endian)) {
342 llvm::Triple LE = Target.getLittleEndianArchVariant();
343 if (LE.getArch() != llvm::Triple::UnknownArch)
344 Target = std::move(LE);
345 } else {
346 llvm::Triple BE = Target.getBigEndianArchVariant();
347 if (BE.getArch() != llvm::Triple::UnknownArch)
348 Target = std::move(BE);
349 }
350 }
351
352 // Skip further flag support on OSes which don't support '-m32' or '-m64'.
Douglas Katzman15a63ed2015-08-12 18:36:12 +0000353 if (Target.getArch() == llvm::Triple::tce ||
354 Target.getOS() == llvm::Triple::Minix)
Artem Belevich959e0542015-07-10 19:47:55 +0000355 return Target;
356
357 // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000358 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
359 options::OPT_m32, options::OPT_m16);
360 if (A) {
Artem Belevich959e0542015-07-10 19:47:55 +0000361 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
362
363 if (A->getOption().matches(options::OPT_m64)) {
364 AT = Target.get64BitArchVariant().getArch();
365 if (Target.getEnvironment() == llvm::Triple::GNUX32)
366 Target.setEnvironment(llvm::Triple::GNU);
367 } else if (A->getOption().matches(options::OPT_mx32) &&
368 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
369 AT = llvm::Triple::x86_64;
370 Target.setEnvironment(llvm::Triple::GNUX32);
371 } else if (A->getOption().matches(options::OPT_m32)) {
372 AT = Target.get32BitArchVariant().getArch();
373 if (Target.getEnvironment() == llvm::Triple::GNUX32)
374 Target.setEnvironment(llvm::Triple::GNU);
375 } else if (A->getOption().matches(options::OPT_m16) &&
376 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
377 AT = llvm::Triple::x86;
378 Target.setEnvironment(llvm::Triple::CODE16);
379 }
380
381 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
382 Target.setArch(AT);
383 }
384
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000385 // Handle -miamcu flag.
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000386 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {
387 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
388 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu"
389 << Target.str();
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000390
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000391 if (A && !A->getOption().matches(options::OPT_m32))
392 D.Diag(diag::err_drv_argument_not_allowed_with)
393 << "-miamcu" << A->getBaseArg().getAsString(Args);
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000394
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000395 Target.setArch(llvm::Triple::x86);
396 Target.setArchName("i586");
397 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
398 Target.setEnvironmentName("");
399 Target.setOS(llvm::Triple::ELFIAMCU);
400 Target.setVendor(llvm::Triple::UnknownVendor);
401 Target.setVendorName("intel");
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000402 }
403
Artem Belevich959e0542015-07-10 19:47:55 +0000404 return Target;
405}
406
Teresa Johnson945bc502015-10-15 20:35:53 +0000407// \brief Parse the LTO options and record the type of LTO compilation
408// based on which -f(no-)?lto(=.*)? option occurs last.
409void Driver::setLTOMode(const llvm::opt::ArgList &Args) {
410 LTOMode = LTOK_None;
411 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
412 options::OPT_fno_lto, false))
413 return;
414
415 StringRef LTOName("full");
416
417 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
Teresa Johnson6ef80dc2015-11-02 18:03:12 +0000418 if (A)
419 LTOName = A->getValue();
Teresa Johnson945bc502015-10-15 20:35:53 +0000420
421 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
422 .Case("full", LTOK_Full)
423 .Case("thin", LTOK_Thin)
424 .Default(LTOK_Unknown);
425
426 if (LTOMode == LTOK_Unknown) {
427 assert(A);
428 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
429 << A->getValue();
430 }
431}
432
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000433void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
434 InputList &Inputs) {
435
436 //
437 // CUDA
438 //
439 // We need to generate a CUDA toolchain if any of the inputs has a CUDA type.
440 if (llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
441 return types::isCuda(I.first);
442 })) {
443 const ToolChain &TC = getToolChain(
444 C.getInputArgs(),
Samuel Antaod06239d2016-07-15 23:13:27 +0000445 llvm::Triple(C.getSingleOffloadToolChain<Action::OFK_Host>()
446 ->getTriple()
447 .isArch64Bit()
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000448 ? "nvptx64-nvidia-cuda"
449 : "nvptx-nvidia-cuda"));
450 C.addOffloadDeviceToolChain(&TC, Action::OFK_Cuda);
451 }
452
453 //
454 // TODO: Add support for other offloading programming models here.
455 //
456
457 return;
458}
459
Chris Lattner54b16772011-07-23 17:14:25 +0000460Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000461 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
462
Eric Christopherf901e852011-08-17 22:59:59 +0000463 // FIXME: Handle environment options which affect driver behavior, somewhere
Bill Wendlingadbeb9f2012-03-12 21:24:57 +0000464 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
Chad Rosier82301162011-09-14 00:47:55 +0000465
David Majnemer85c25b42016-07-24 17:44:03 +0000466 if (Optional<std::string> CompilerPathValue =
467 llvm::sys::Process::GetEnv("COMPILER_PATH")) {
468 StringRef CompilerPath = *CompilerPathValue;
Chad Rosier82301162011-09-14 00:47:55 +0000469 while (!CompilerPath.empty()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000470 std::pair<StringRef, StringRef> Split =
471 CompilerPath.split(llvm::sys::EnvPathSeparator);
Chad Rosier82301162011-09-14 00:47:55 +0000472 PrefixDirs.push_back(Split.first);
473 CompilerPath = Split.second;
474 }
475 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000476
Hans Wennborg70850d82013-07-18 20:29:38 +0000477 // We look for the driver mode option early, because the mode can affect
478 // how other options are parsed.
Zachary Turneraff19c32016-08-12 17:47:52 +0000479 ParseDriverMode(ClangExecutable, ArgList.slice(1));
Hans Wennborg70850d82013-07-18 20:29:38 +0000480
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000481 // FIXME: What are we going to do with -V and -b?
482
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000483 // FIXME: This stuff needs to go into the Compilation, not the driver.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000484 bool CCCPrintPhases;
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000485
David Blaikie69a1d8c2015-06-22 22:07:27 +0000486 InputArgList Args = ParseArgStrings(ArgList.slice(1));
Daniel Dunbaracd69572009-12-04 21:55:23 +0000487
Filipe Cabecinhas136f35e2015-07-18 06:35:24 +0000488 // Silence driver warnings if requested
489 Diags.setIgnoreAllWarnings(Args.hasArg(options::OPT_w));
490
Rafael Espindola59ae7992009-12-07 18:28:29 +0000491 // -no-canonical-prefixes is used very early in main.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000492 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
Rafael Espindola59ae7992009-12-07 18:28:29 +0000493
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000494 // Ignore -pipe.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000495 Args.ClaimAllArgs(options::OPT_pipe);
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000496
Daniel Dunbaracd69572009-12-04 21:55:23 +0000497 // Extract -ccc args.
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000498 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000499 // FIXME: We need to figure out where this behavior should live. Most of it
500 // should be outside in the client; the parts that aren't should have proper
501 // options, either by introducing new ones or by overloading gcc ones like -V
502 // or -b.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000503 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
David Blaikie69a1d8c2015-06-22 22:07:27 +0000504 CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings);
505 if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
Richard Smithbd55daf2012-11-01 04:30:05 +0000506 CCCGenericGCCName = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000507 CCCUsePCH =
508 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
Joerg Sonnenberger17d75512012-02-22 19:15:16 +0000509 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
510 // and getToolChain is const.
Hans Wennborg2e274592013-08-13 23:38:57 +0000511 if (IsCLMode()) {
Hans Wennborg73609a02014-03-28 01:19:04 +0000512 // clang-cl targets MSVC-style Win32.
Hans Wennborg2e274592013-08-13 23:38:57 +0000513 llvm::Triple T(DefaultTargetTriple);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000514 T.setOS(llvm::Triple::Win32);
Hans Wennborg0f0e8d62015-09-18 17:11:50 +0000515 T.setVendor(llvm::Triple::PC);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000516 T.setEnvironment(llvm::Triple::MSVC);
Hans Wennborg2e274592013-08-13 23:38:57 +0000517 DefaultTargetTriple = T.str();
518 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000519 if (const Arg *A = Args.getLastArg(options::OPT_target))
Richard Smithbd55daf2012-11-01 04:30:05 +0000520 DefaultTargetTriple = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000521 if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
Richard Smithbd55daf2012-11-01 04:30:05 +0000522 Dir = InstalledDir = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000523 for (const Arg *A : Args.filtered(options::OPT_B)) {
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000524 A->claim();
Richard Smithbd55daf2012-11-01 04:30:05 +0000525 PrefixDirs.push_back(A->getValue(0));
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000526 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000527 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000528 SysRoot = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000529 if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +0000530 DyldPrefix = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000531 if (Args.hasArg(options::OPT_nostdlib))
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +0000532 UseStdLib = false;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000533
David Blaikie69a1d8c2015-06-22 22:07:27 +0000534 if (const Arg *A = Args.getLastArg(options::OPT_resource_dir))
Bob Wilsona20a1da2013-03-23 05:17:59 +0000535 ResourceDir = A->getValue();
Jim Grosbach061dabf2013-03-12 20:17:58 +0000536
David Blaikie69a1d8c2015-06-22 22:07:27 +0000537 if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000538 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
539 .Case("cwd", SaveTempsCwd)
540 .Case("obj", SaveTempsObj)
541 .Default(SaveTempsCwd);
542 }
543
Steven Wu1257cd82016-05-18 17:04:52 +0000544 setLTOMode(Args);
545
Steven Wu574b0f22016-03-01 01:07:58 +0000546 // Ignore -fembed-bitcode options with LTO
547 // since the output will be bitcode anyway.
Steven Wu1257cd82016-05-18 17:04:52 +0000548 if (getLTOMode() == LTOK_None) {
Steven Wu27fb5222016-05-11 16:26:03 +0000549 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
550 StringRef Name = A->getValue();
551 unsigned Model = llvm::StringSwitch<unsigned>(Name)
552 .Case("off", EmbedNone)
553 .Case("all", EmbedBitcode)
554 .Case("bitcode", EmbedBitcode)
555 .Case("marker", EmbedMarker)
556 .Default(~0U);
557 if (Model == ~0U) {
558 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
559 << Name;
560 } else
561 BitcodeEmbed = static_cast<BitcodeEmbedMode>(Model);
562 }
Steven Wu574b0f22016-03-01 01:07:58 +0000563 } else {
564 // claim the bitcode option under LTO so no warning is issued.
Steven Wu27fb5222016-05-11 16:26:03 +0000565 Args.ClaimAllArgs(options::OPT_fembed_bitcode_EQ);
Steven Wu574b0f22016-03-01 01:07:58 +0000566 }
567
David Blaikie69a1d8c2015-06-22 22:07:27 +0000568 std::unique_ptr<llvm::opt::InputArgList> UArgs =
569 llvm::make_unique<InputArgList>(std::move(Args));
570
Daniel Dunbar775d4062010-06-11 22:00:26 +0000571 // Perform the default argument translations.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000572 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
Daniel Dunbar775d4062010-06-11 22:00:26 +0000573
Chandler Carruthcb916192012-01-25 08:49:21 +0000574 // Owned by the host.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000575 const ToolChain &TC = getToolChain(
576 *UArgs, computeTargetTriple(*this, DefaultTargetTriple, *UArgs));
Chandler Carruthcb916192012-01-25 08:49:21 +0000577
Daniel Dunbar3ce436d2009-03-16 06:42:30 +0000578 // The compilation takes ownership of Args.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000579 Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000580
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000581 if (!HandleImmediateArgs(*C))
582 return C;
583
Chad Rosierecdede82011-08-12 22:08:57 +0000584 // Construct the list of inputs.
585 InputList Inputs;
Hans Wennborged1d0722013-08-13 21:32:29 +0000586 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
Chad Rosierecdede82011-08-12 22:08:57 +0000587
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000588 // Populate the tool chains for the offloading devices, if any.
589 CreateOffloadingDeviceToolChains(*C, Inputs);
Justin Lebar0e450a52016-03-30 23:30:25 +0000590
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000591 // Construct the list of abstract actions to perform for this compilation. On
Tim Northover157d9112014-01-16 08:48:16 +0000592 // MachO targets this uses the driver-driver and universal actions.
593 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000594 BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000595 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000596 BuildActions(*C, C->getArgs(), Inputs, C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000597
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000598 if (CCCPrintPhases) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000599 PrintActions(*C);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000600 return C;
601 }
602
603 BuildJobs(*C);
Daniel Dunbaradc91e62009-03-15 01:38:15 +0000604
605 return C;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000606}
607
Justin Bognered9cbe02015-07-09 06:58:31 +0000608static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args) {
609 llvm::opt::ArgStringList ASL;
610 for (const auto *A : Args)
611 A->render(Args, ASL);
612
613 for (auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
614 if (I != ASL.begin())
615 OS << ' ';
616 Command::printArg(OS, *I, true);
617 }
618 OS << '\n';
619}
620
Eric Christopherf901e852011-08-17 22:59:59 +0000621// When clang crashes, produce diagnostic information including the fully
622// preprocessed source file(s). Request that the developer attach the
Chad Rosierbe10f982011-08-02 17:58:04 +0000623// diagnostic information to a bug report.
624void Driver::generateCompilationDiagnostics(Compilation &C,
Justin Bognere1a33d12014-10-20 21:02:05 +0000625 const Command &FailingCommand) {
Chad Rosier877c0a22012-02-22 00:30:39 +0000626 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
Chad Rosier62135492012-07-09 17:31:28 +0000627 return;
Chad Rosierbee5a1d2012-03-07 00:30:40 +0000628
Chad Rosierdbf46a12013-02-01 18:30:26 +0000629 // Don't try to generate diagnostics for link or dsymutil jobs.
Justin Bognere1a33d12014-10-20 21:02:05 +0000630 if (FailingCommand.getCreator().isLinkJob() ||
631 FailingCommand.getCreator().isDsymutilJob())
Chad Rosier877c0a22012-02-22 00:30:39 +0000632 return;
633
Chad Rosier8179f112012-06-19 17:51:34 +0000634 // Print the version of the compiler.
635 PrintVersion(C, llvm::errs());
636
Chad Rosierbe10f982011-08-02 17:58:04 +0000637 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000638 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
639 "crash backtrace, preprocessed source, and associated run script.";
Chad Rosierbe10f982011-08-02 17:58:04 +0000640
641 // Suppress driver output and emit preprocessor output to temp file.
Hans Wennborg70850d82013-07-18 20:29:38 +0000642 Mode = CPPMode;
Chad Rosierbe10f982011-08-02 17:58:04 +0000643 CCGenDiagnostics = true;
644
Chad Rosiercdb008d2011-11-02 21:29:05 +0000645 // Save the original job command(s).
Justin Bogner25645152014-10-21 17:24:44 +0000646 Command Cmd = FailingCommand;
Chad Rosiercdb008d2011-11-02 21:29:05 +0000647
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000648 // Keep track of whether we produce any errors while trying to produce
649 // preprocessed sources.
650 DiagnosticErrorTrap Trap(Diags);
651
652 // Suppress tool output.
Chad Rosierbe10f982011-08-02 17:58:04 +0000653 C.initCompilationForDiagnostics();
Chad Rosierecdede82011-08-12 22:08:57 +0000654
655 // Construct the list of inputs.
656 InputList Inputs;
657 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000658
Chad Rosier4f81fc22011-08-12 23:30:05 +0000659 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000660 bool IgnoreInput = false;
661
662 // Ignore input from stdin or any inputs that cannot be preprocessed.
Paul Robinsonf44157d2014-04-28 22:24:44 +0000663 // Check type first as not all linker inputs have a value.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000664 if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
Paul Robinsonf44157d2014-04-28 22:24:44 +0000665 IgnoreInput = true;
666 } else if (!strcmp(it->second->getValue(), "-")) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000667 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000668 << "Error generating preprocessed source(s) - "
669 "ignoring input from stdin.";
Chad Rosierd57133d2011-08-18 00:22:25 +0000670 IgnoreInput = true;
Chad Rosierd57133d2011-08-18 00:22:25 +0000671 }
672
673 if (IgnoreInput) {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000674 it = Inputs.erase(it);
675 ie = Inputs.end();
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000676 } else {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000677 ++it;
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000678 }
Chad Rosier4f81fc22011-08-12 23:30:05 +0000679 }
Chad Rosierd57133d2011-08-18 00:22:25 +0000680
Chad Rosierc5103c32013-01-29 23:57:10 +0000681 if (Inputs.empty()) {
682 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000683 << "Error generating preprocessed source(s) - "
684 "no preprocessable inputs.";
Chad Rosierc5103c32013-01-29 23:57:10 +0000685 return;
686 }
687
Chad Rosiere75ef402011-09-06 23:52:36 +0000688 // Don't attempt to generate preprocessed files if multiple -arch options are
Chad Rosier636d2832012-02-13 18:16:28 +0000689 // used, unless they're all duplicates.
690 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000691 for (const Arg *A : C.getArgs()) {
Chad Rosiere75ef402011-09-06 23:52:36 +0000692 if (A->getOption().matches(options::OPT_arch)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000693 StringRef ArchName = A->getValue();
Chad Rosier636d2832012-02-13 18:16:28 +0000694 ArchNames.insert(ArchName);
Chad Rosiere75ef402011-09-06 23:52:36 +0000695 }
696 }
Chad Rosier636d2832012-02-13 18:16:28 +0000697 if (ArchNames.size() > 1) {
698 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000699 << "Error generating preprocessed source(s) - cannot generate "
700 "preprocessed source with multiple -arch options.";
Chad Rosier636d2832012-02-13 18:16:28 +0000701 return;
702 }
Chad Rosiere75ef402011-09-06 23:52:36 +0000703
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000704 // Construct the list of abstract actions to perform for this compilation. On
705 // Darwin OSes this uses the driver-driver and builds universal actions.
Chandler Carruthcb916192012-01-25 08:49:21 +0000706 const ToolChain &TC = C.getDefaultToolChain();
Tim Northover157d9112014-01-16 08:48:16 +0000707 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000708 BuildUniversalActions(C, TC, Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000709 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000710 BuildActions(C, C.getArgs(), Inputs, C.getActions());
Chad Rosierbe10f982011-08-02 17:58:04 +0000711
712 BuildJobs(C);
713
714 // If there were errors building the compilation, quit now.
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000715 if (Trap.hasErrorOccurred()) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000716 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000717 << "Error generating preprocessed source(s).";
Chad Rosierbe10f982011-08-02 17:58:04 +0000718 return;
719 }
720
721 // Generate preprocessed output.
Chad Rosierdd60e092013-01-29 20:15:05 +0000722 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
Justin Bogner0cd92482015-07-02 22:52:08 +0000723 C.ExecuteJobs(C.getJobs(), FailingCommands);
Chad Rosierbe10f982011-08-02 17:58:04 +0000724
Justin Bognerbc89b182014-10-20 21:20:27 +0000725 // If any of the preprocessing commands failed, clean up and exit.
726 if (!FailingCommands.empty()) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000727 if (!isSaveTempsEnabled())
Chad Rosierbe10f982011-08-02 17:58:04 +0000728 C.CleanupFileList(C.getTempFiles(), true);
729
730 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000731 << "Error generating preprocessed source(s).";
Justin Bognerbc89b182014-10-20 21:20:27 +0000732 return;
Chad Rosierbe10f982011-08-02 17:58:04 +0000733 }
Justin Bognerbc89b182014-10-20 21:20:27 +0000734
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000735 const ArgStringList &TempFiles = C.getTempFiles();
736 if (TempFiles.empty()) {
737 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000738 << "Error generating preprocessed source(s).";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000739 return;
740 }
741
Justin Bognerbc89b182014-10-20 21:20:27 +0000742 Diag(clang::diag::note_drv_command_failed_diag_msg)
743 << "\n********************\n\n"
744 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
745 "Preprocessed source(s) and associated run script(s) are located at:";
Justin Bognerbc89b182014-10-20 21:20:27 +0000746
Justin Bogner659ecc32014-10-20 22:47:23 +0000747 SmallString<128> VFS;
748 for (const char *TempFile : TempFiles) {
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000749 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
Justin Bogner659ecc32014-10-20 22:47:23 +0000750 if (StringRef(TempFile).endswith(".cache")) {
751 // In some cases (modules) we'll dump extra data to help with reproducing
752 // the crash into a directory next to the output.
753 VFS = llvm::sys::path::filename(TempFile);
754 llvm::sys::path::append(VFS, "vfs", "vfs.yaml");
755 }
756 }
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000757
758 // Assume associated files are based off of the first temporary file.
Justin Bogner25645152014-10-21 17:24:44 +0000759 CrashReportInfo CrashInfo(TempFiles[0], VFS);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000760
Justin Bogner25645152014-10-21 17:24:44 +0000761 std::string Script = CrashInfo.Filename.rsplit('.').first.str() + ".sh";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000762 std::error_code EC;
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000763 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl);
764 if (EC) {
765 Diag(clang::diag::note_drv_command_failed_diag_msg)
766 << "Error generating run script: " + Script + " " + EC.message();
767 } else {
Justin Bogner42220ed2015-03-12 00:14:35 +0000768 ScriptOS << "# Crash reproducer for " << getClangFullVersion() << "\n"
Justin Bognered9cbe02015-07-09 06:58:31 +0000769 << "# Driver args: ";
770 printArgList(ScriptOS, C.getInputArgs());
771 ScriptOS << "# Original command: ";
Justin Bogner42220ed2015-03-12 00:14:35 +0000772 Cmd.Print(ScriptOS, "\n", /*Quote=*/true);
Justin Bogner33bdbc62014-10-21 18:03:08 +0000773 Cmd.Print(ScriptOS, "\n", /*Quote=*/true, &CrashInfo);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000774 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
Justin Bognerbc89b182014-10-20 21:20:27 +0000775 }
Saleem Abdulrasool3661a822015-01-12 02:33:09 +0000776
777 for (const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file,
778 options::OPT_frewrite_map_file_EQ))
779 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
780
Justin Bognerbc89b182014-10-20 21:20:27 +0000781 Diag(clang::diag::note_drv_command_failed_diag_msg)
782 << "\n\n********************";
Chad Rosierbe10f982011-08-02 17:58:04 +0000783}
784
Justin Bogner0cd92482015-07-02 22:52:08 +0000785void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) {
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000786 // Since commandLineFitsWithinSystemLimits() may underestimate system's capacity
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000787 // if the tool does not support response files, there is a chance/ that things
788 // will just work without a response file, so we silently just skip it.
Justin Bogner0cd92482015-07-02 22:52:08 +0000789 if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None ||
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000790 llvm::sys::commandLineFitsWithinSystemLimits(Cmd.getExecutable(), Cmd.getArguments()))
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000791 return;
792
793 std::string TmpName = GetTemporaryPath("response", "txt");
Justin Bogner0cd92482015-07-02 22:52:08 +0000794 Cmd.setResponseFile(
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000795 C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())));
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000796}
797
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000798int Driver::ExecuteCompilation(
799 Compilation &C,
800 SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) {
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000801 // Just print if -### was present.
802 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Hans Wennborgb212b342013-09-12 18:23:34 +0000803 C.getJobs().Print(llvm::errs(), "\n", true);
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000804 return 0;
805 }
806
807 // If there were errors building the compilation, quit now.
Chad Rosierbe10f982011-08-02 17:58:04 +0000808 if (Diags.hasErrorOccurred())
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000809 return 1;
810
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000811 // Set up response file names for each command, if necessary
Justin Bogner0cd92482015-07-02 22:52:08 +0000812 for (auto &Job : C.getJobs())
813 setUpResponseFiles(C, Job);
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000814
Justin Bogner0cd92482015-07-02 22:52:08 +0000815 C.ExecuteJobs(C.getJobs(), FailingCommands);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000816
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000817 // Remove temp files.
818 C.CleanupFileList(C.getTempFiles());
819
Daniel Dunbar07494792010-05-22 00:37:20 +0000820 // If the command succeeded, we are done.
Chad Rosierdd60e092013-01-29 20:15:05 +0000821 if (FailingCommands.empty())
822 return 0;
Daniel Dunbar07494792010-05-22 00:37:20 +0000823
Chad Rosierdd60e092013-01-29 20:15:05 +0000824 // Otherwise, remove result files and print extra information about abnormal
825 // failures.
Douglas Katzman6bbffc42015-06-25 18:51:37 +0000826 for (const auto &CmdPair : FailingCommands) {
827 int Res = CmdPair.first;
828 const Command *FailingCommand = CmdPair.second;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000829
Chad Rosierdd60e092013-01-29 20:15:05 +0000830 // Remove result files if we're not saving temps.
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000831 if (!isSaveTempsEnabled()) {
Chad Rosierdd60e092013-01-29 20:15:05 +0000832 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
833 C.CleanupFileMap(C.getResultFiles(), JA, true);
834
835 // Failure result files are valid unless we crashed.
836 if (Res < 0)
837 C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
838 }
839
840 // Print extra information about abnormal failures, if possible.
841 //
842 // This is ad-hoc, but we don't want to be excessively noisy. If the result
Justin Bogner5aaf2e72014-06-26 20:59:36 +0000843 // status was 1, assume the command failed normally. In particular, if it
Chad Rosierdd60e092013-01-29 20:15:05 +0000844 // was the compiler then assume it gave a reasonable error code. Failures
845 // in other tools are less common, and they generally have worse
846 // diagnostics, so always print the diagnostic there.
847 const Tool &FailingTool = FailingCommand->getCreator();
848
849 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
850 // FIXME: See FIXME above regarding result code interpretation.
851 if (Res < 0)
852 Diag(clang::diag::err_drv_command_signalled)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000853 << FailingTool.getShortName();
Chad Rosierdd60e092013-01-29 20:15:05 +0000854 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000855 Diag(clang::diag::err_drv_command_failed) << FailingTool.getShortName()
856 << Res;
Chad Rosierdd60e092013-01-29 20:15:05 +0000857 }
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000858 }
Chad Rosierdd60e092013-01-29 20:15:05 +0000859 return 0;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000860}
861
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000862void Driver::PrintHelp(bool ShowHidden) const {
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000863 unsigned IncludedFlagsBitmask;
864 unsigned ExcludedFlagsBitmask;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +0000865 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000866 getIncludeExcludeOptionFlagMasks();
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000867
868 ExcludedFlagsBitmask |= options::NoDriverOption;
869 if (!ShowHidden)
870 ExcludedFlagsBitmask |= HelpHidden;
871
872 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
873 IncludedFlagsBitmask, ExcludedFlagsBitmask);
Daniel Dunbar7c925282009-03-31 21:38:17 +0000874}
875
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000876void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000877 // FIXME: The following handlers should use a callback mechanism, we don't
878 // know what the client would like to do.
Ted Kremenek4c0df3d2010-01-23 02:11:34 +0000879 OS << getClangFullVersion() << '\n';
Daniel Dunbarb10248802009-03-26 16:09:13 +0000880 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000881 OS << "Target: " << TC.getTripleString() << '\n';
Daniel Dunbar10978e42009-06-16 23:32:58 +0000882
883 // Print the threading model.
Jonathan Roelofsb140a102014-10-03 21:57:44 +0000884 if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) {
885 // Don't print if the ToolChain would have barfed on it already
886 if (TC.isThreadModelSupported(A->getValue()))
887 OS << "Thread model: " << A->getValue();
888 } else
889 OS << "Thread model: " << TC.getThreadModel();
890 OS << '\n';
Chandler Carruth9ade6a92015-08-05 17:07:33 +0000891
892 // Print out the install directory.
893 OS << "InstalledDir: " << InstalledDir << '\n';
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000894}
895
Chris Lattner86ed5b02010-05-05 05:53:24 +0000896/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
897/// option.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000898static void PrintDiagnosticCategories(raw_ostream &OS) {
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000899 // Skip the empty category.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000900 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max;
901 ++i)
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000902 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
Chris Lattner86ed5b02010-05-05 05:53:24 +0000903}
904
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000905bool Driver::HandleImmediateArgs(const Compilation &C) {
Daniel Dunbar18974bd2010-06-11 22:00:19 +0000906 // The order these options are handled in gcc is all over the place, but we
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000907 // don't expect inconsistencies w.r.t. that to matter in practice.
Daniel Dunbar7c925282009-03-31 21:38:17 +0000908
Daniel Dunbar1b09e042010-09-17 02:47:28 +0000909 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
910 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
911 return false;
912 }
913
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000914 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
Daniel Dunbare26e5002011-01-12 00:43:47 +0000915 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
916 // return an answer which matches our definition of __VERSION__.
917 //
918 // If we want to return a more correct answer some day, then we should
919 // introduce a non-pedantically GCC compatible mode to Clang in which we
920 // provide sensible definitions for -dumpversion, __VERSION__, etc.
921 llvm::outs() << "4.2.1\n";
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000922 return false;
923 }
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000924
Chris Lattner86ed5b02010-05-05 05:53:24 +0000925 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
926 PrintDiagnosticCategories(llvm::outs());
927 return false;
928 }
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000929
James Molloya3c85b82012-05-01 14:57:16 +0000930 if (C.getArgs().hasArg(options::OPT_help) ||
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000931 C.getArgs().hasArg(options::OPT__help_hidden)) {
932 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +0000933 return false;
934 }
935
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000936 if (C.getArgs().hasArg(options::OPT__version)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000937 // Follow gcc behavior and use stdout for --version and stderr for -v.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000938 PrintVersion(C, llvm::outs());
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000939 return false;
940 }
941
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000942 if (C.getArgs().hasArg(options::OPT_v) ||
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000943 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000944 PrintVersion(C, llvm::errs());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000945 SuppressMissingInputWarning = true;
946 }
947
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000948 const ToolChain &TC = C.getDefaultToolChain();
Chandler Carruth0ae39aa2013-07-30 17:57:09 +0000949
950 if (C.getArgs().hasArg(options::OPT_v))
951 TC.printVerboseInfo(llvm::errs());
952
Daniel Dunbard972e222009-03-20 04:37:21 +0000953 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
954 llvm::outs() << "programs: =";
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000955 bool separator = false;
956 for (const std::string &Path : TC.getProgramPaths()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000957 if (separator)
958 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000959 llvm::outs() << Path;
960 separator = true;
Daniel Dunbard972e222009-03-20 04:37:21 +0000961 }
962 llvm::outs() << "\n";
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000963 llvm::outs() << "libraries: =" << ResourceDir;
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000964
Sebastian Pop980920a2012-04-16 04:16:43 +0000965 StringRef sysroot = C.getSysRoot();
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000966
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000967 for (const std::string &Path : TC.getFilePaths()) {
968 // Always print a separator. ResourceDir was the first item shown.
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000969 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000970 // Interpretation of leading '=' is needed only for NetBSD.
971 if (Path[0] == '=')
Douglas Katzman26eabf62015-06-24 15:10:30 +0000972 llvm::outs() << sysroot << Path.substr(1);
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000973 else
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000974 llvm::outs() << Path;
Daniel Dunbard972e222009-03-20 04:37:21 +0000975 }
976 llvm::outs() << "\n";
Daniel Dunbar7c925282009-03-31 21:38:17 +0000977 return false;
Daniel Dunbard972e222009-03-20 04:37:21 +0000978 }
979
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000980 // FIXME: The following handlers should use a callback mechanism, we don't
981 // know what the client would like to do.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000982 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000983 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000984 return false;
985 }
986
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000987 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000988 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000989 return false;
990 }
991
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000992 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000993 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000994 return false;
995 }
996
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000997 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +0000998 for (const Multilib &Multilib : TC.getMultilibs())
999 llvm::outs() << Multilib << "\n";
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +00001000 return false;
1001 }
1002
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001003 if (C.getArgs().hasArg(options::OPT_print_multi_directory)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +00001004 for (const Multilib &Multilib : TC.getMultilibs()) {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001005 if (Multilib.gccSuffix().empty())
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001006 llvm::outs() << ".\n";
1007 else {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001008 StringRef Suffix(Multilib.gccSuffix());
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001009 assert(Suffix.front() == '/');
1010 llvm::outs() << Suffix.substr(1) << "\n";
1011 }
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001012 }
Jonathan Roelofs0e7ec602014-02-12 01:29:25 +00001013 return false;
1014 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001015 return true;
1016}
1017
Douglas Katzmanfd528672015-06-11 15:05:22 +00001018// Display an action graph human-readably. Action A is the "sink" node
1019// and latest-occuring action. Traversal is in pre-order, visiting the
1020// inputs to each action before printing the action itself.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001021static unsigned PrintActions1(const Compilation &C, Action *A,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001022 std::map<Action *, unsigned> &Ids) {
Douglas Katzmanfd528672015-06-11 15:05:22 +00001023 if (Ids.count(A)) // A was already visited.
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001024 return Ids[A];
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001025
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001026 std::string str;
1027 llvm::raw_string_ostream os(str);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001028
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001029 os << Action::getClassName(A->getKind()) << ", ";
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001030 if (InputAction *IA = dyn_cast<InputAction>(A)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001031 os << "\"" << IA->getInputArg().getValue() << "\"";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001032 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001033 os << '"' << BIA->getArchName() << '"' << ", {"
Nico Weber5a459f82016-02-23 19:30:43 +00001034 << PrintActions1(C, *BIA->input_begin(), Ids) << "}";
Samuel Antaod06239d2016-07-15 23:13:27 +00001035 } else if (OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1036 bool IsFirst = true;
1037 OA->doOnEachDependence(
1038 [&](Action *A, const ToolChain *TC, const char *BoundArch) {
1039 // E.g. for two CUDA device dependences whose bound arch is sm_20 and
1040 // sm_35 this will generate:
1041 // "cuda-device" (nvptx64-nvidia-cuda:sm_20) {#ID}, "cuda-device"
1042 // (nvptx64-nvidia-cuda:sm_35) {#ID}
1043 if (!IsFirst)
1044 os << ", ";
1045 os << '"';
1046 if (TC)
1047 os << A->getOffloadingKindPrefix();
1048 else
1049 os << "host";
1050 os << " (";
1051 os << TC->getTriple().normalize();
1052
1053 if (BoundArch)
1054 os << ":" << BoundArch;
1055 os << ")";
1056 os << '"';
1057 os << " {" << PrintActions1(C, A, Ids) << "}";
1058 IsFirst = false;
1059 });
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001060 } else {
Samuel Antaod06239d2016-07-15 23:13:27 +00001061 const ActionList *AL = &A->getInputs();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001062
Artem Belevich23256752015-09-22 17:23:09 +00001063 if (AL->size()) {
1064 const char *Prefix = "{";
1065 for (Action *PreRequisite : *AL) {
1066 os << Prefix << PrintActions1(C, PreRequisite, Ids);
1067 Prefix = ", ";
1068 }
1069 os << "}";
1070 } else
1071 os << "{}";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001072 }
1073
Samuel Antaod06239d2016-07-15 23:13:27 +00001074 // Append offload info for all options other than the offloading action
1075 // itself (e.g. (cuda-device, sm_20) or (cuda-host)).
1076 std::string offload_str;
1077 llvm::raw_string_ostream offload_os(offload_str);
1078 if (!isa<OffloadAction>(A)) {
1079 auto S = A->getOffloadingKindPrefix();
1080 if (!S.empty()) {
1081 offload_os << ", (" << S;
1082 if (A->getOffloadingArch())
1083 offload_os << ", " << A->getOffloadingArch();
1084 offload_os << ")";
1085 }
1086 }
1087
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001088 unsigned Id = Ids.size();
1089 Ids[A] = Id;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001090 llvm::errs() << Id << ": " << os.str() << ", "
Samuel Antaod06239d2016-07-15 23:13:27 +00001091 << types::getTypeName(A->getType()) << offload_os.str() << "\n";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001092
1093 return Id;
1094}
1095
Douglas Katzmanfd528672015-06-11 15:05:22 +00001096// Print the action graphs in a compilation C.
1097// For example "clang -c file1.c file2.c" is composed of two subgraphs.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001098void Driver::PrintActions(const Compilation &C) const {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001099 std::map<Action *, unsigned> Ids;
1100 for (Action *A : C.getActions())
1101 PrintActions1(C, A, Ids);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001102}
1103
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +00001104/// \brief Check whether the given input tree contains any compilation or
1105/// assembly actions.
1106static bool ContainsCompileOrAssembleAction(const Action *A) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001107 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
Bob Wilson23a55f12014-12-21 07:00:00 +00001108 isa<AssembleJobAction>(A))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001109 return true;
1110
Nico Weber5a459f82016-02-23 19:30:43 +00001111 for (const Action *Input : A->inputs())
Nico Weberfb80f962015-09-19 21:36:51 +00001112 if (ContainsCompileOrAssembleAction(Input))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001113 return true;
1114
1115 return false;
1116}
1117
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00001118void Driver::BuildUniversalActions(Compilation &C, const ToolChain &TC,
1119 const InputList &BAInputs) const {
1120 DerivedArgList &Args = C.getArgs();
1121 ActionList &Actions = C.getActions();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001122 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
1123 // Collect the list of architectures. Duplicates are allowed, but should only
1124 // be handled once (in the order seen).
Daniel Dunbare5dc4822009-03-13 20:33:35 +00001125 llvm::StringSet<> ArchNames;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001126 SmallVector<const char *, 4> Archs;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001127 for (Arg *A : Args) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001128 if (A->getOption().matches(options::OPT_arch)) {
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001129 // Validate the option here; we don't save the type here because its
1130 // particular spelling may participate in other driver choices.
1131 llvm::Triple::ArchType Arch =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001132 tools::darwin::getArchTypeForMachOArchName(A->getValue());
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001133 if (Arch == llvm::Triple::UnknownArch) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001134 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001135 continue;
1136 }
1137
Daniel Dunbar2da02722009-03-19 07:55:12 +00001138 A->claim();
David Blaikie61b86d42014-11-19 02:56:13 +00001139 if (ArchNames.insert(A->getValue()).second)
Richard Smithbd55daf2012-11-01 04:30:05 +00001140 Archs.push_back(A->getValue());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001141 }
1142 }
1143
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001144 // When there is no explicit arch for this platform, make sure we still bind
1145 // the architecture (to the default) so that -Xarch_ is handled correctly.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001146 if (!Archs.size())
Daniel Dunbarc3bd9f52012-11-08 03:38:26 +00001147 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001148
Daniel Dunbarf479c122009-03-12 18:40:18 +00001149 ActionList SingleActions;
Justin Lebar0f3474c2016-02-11 02:00:50 +00001150 BuildActions(C, Args, BAInputs, SingleActions);
Daniel Dunbarf479c122009-03-12 18:40:18 +00001151
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001152 // Add in arch bindings for every top level action, as well as lipo and
1153 // dsymutil steps if needed.
Nico Weberfb80f962015-09-19 21:36:51 +00001154 for (Action* Act : SingleActions) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001155 // Make sure we can lipo this kind of output. If not (and it is an actual
1156 // output) then we disallow, since we can't create an output file with the
1157 // right name without overwriting it. We could remove this oddity by just
1158 // changing the output names to include the arch, which would also fix
Daniel Dunbarf479c122009-03-12 18:40:18 +00001159 // -save-temps. Compatibility wins for now.
1160
Daniel Dunbare2ca3bd2009-03-13 17:46:02 +00001161 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
Daniel Dunbarf479c122009-03-12 18:40:18 +00001162 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001163 << types::getTypeName(Act->getType());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001164
1165 ActionList Inputs;
Justin Lebar41094612016-01-11 23:07:27 +00001166 for (unsigned i = 0, e = Archs.size(); i != e; ++i)
1167 Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i]));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001168
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001169 // Lipo if necessary, we do it this way because we need to set the arch flag
1170 // so that -Xarch_ gets overwritten.
Daniel Dunbarf479c122009-03-12 18:40:18 +00001171 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1172 Actions.append(Inputs.begin(), Inputs.end());
1173 else
Justin Lebar41094612016-01-11 23:07:27 +00001174 Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType()));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001175
Eric Christopher65c05fa2012-02-06 19:43:51 +00001176 // Handle debug info queries.
1177 Arg *A = Args.getLastArg(options::OPT_g_Group);
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001178 if (A && !A->getOption().matches(options::OPT_g0) &&
1179 !A->getOption().matches(options::OPT_gstabs) &&
1180 ContainsCompileOrAssembleAction(Actions.back())) {
Chad Rosier62135492012-07-09 17:31:28 +00001181
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001182 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
1183 // have a compile input. We need to run 'dsymutil' ourselves in such cases
Eric Christopher776c26f2013-01-28 17:39:03 +00001184 // because the debug info will refer to a temporary object file which
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001185 // will be removed at the end of the compilation process.
1186 if (Act->getType() == types::TY_Image) {
1187 ActionList Inputs;
1188 Inputs.push_back(Actions.back());
1189 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001190 Actions.push_back(
1191 C.MakeAction<DsymutilJobAction>(Inputs, types::TY_dSYM));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001192 }
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001193
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00001194 // Verify the debug info output.
Alp Tokere9d2bfc2014-01-17 02:06:23 +00001195 if (Args.hasArg(options::OPT_verify_debug_info)) {
Justin Lebar41094612016-01-11 23:07:27 +00001196 Action* LastAction = Actions.back();
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001197 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001198 Actions.push_back(C.MakeAction<VerifyDebugInfoJobAction>(
1199 LastAction, types::TY_Nothing));
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001200 }
1201 }
Daniel Dunbarf479c122009-03-12 18:40:18 +00001202 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001203}
1204
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001205/// \brief Check that the file referenced by Value exists. If it doesn't,
1206/// issue a diagnostic and return false.
Alp Toker8c8a8752013-12-03 06:53:35 +00001207static bool DiagnoseInputExistence(const Driver &D, const DerivedArgList &Args,
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001208 StringRef Value, types::ID Ty) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001209 if (!D.getCheckInputsExist())
1210 return true;
1211
1212 // stdin always exists.
1213 if (Value == "-")
1214 return true;
1215
1216 SmallString<64> Path(Value);
1217 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00001218 if (!llvm::sys::path::is_absolute(Path)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001219 SmallString<64> Directory(WorkDir->getValue());
1220 llvm::sys::path::append(Directory, Value);
1221 Path.assign(Directory);
1222 }
1223 }
1224
1225 if (llvm::sys::fs::exists(Twine(Path)))
1226 return true;
1227
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001228 if (D.IsCLMode()) {
1229 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1230 llvm::sys::Process::FindInEnvPath("LIB", Value))
1231 return true;
1232
1233 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1234 // Arguments to the /link flag might cause the linker to search for object
1235 // and library files in paths we don't know about. Don't error in such
1236 // cases.
1237 return true;
1238 }
1239 }
Hans Wennborg23d26a32014-06-18 17:21:50 +00001240
Yaron Keren92e1b622015-03-18 10:17:07 +00001241 D.Diag(clang::diag::err_drv_no_such_file) << Path;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001242 return false;
1243}
1244
Chad Rosierecdede82011-08-12 22:08:57 +00001245// Construct a the list of inputs and their types.
Hans Wennborg55362852014-05-02 22:55:30 +00001246void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
Chad Rosierecdede82011-08-12 22:08:57 +00001247 InputList &Inputs) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001248 // Track the current user specified (-x) input. We also explicitly track the
1249 // argument used to set the type; we only want to claim the type when we
1250 // actually use it, so we warn about unused -x arguments.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001251 types::ID InputType = types::TY_Nothing;
Craig Topper92fc2df2014-05-17 16:56:41 +00001252 Arg *InputTypeArg = nullptr;
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001253
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001254 // The last /TC or /TP option sets the input type to C or C++ globally.
Ehsan Akhgaric249abb2014-09-12 21:44:24 +00001255 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1256 options::OPT__SLASH_TP)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001257 InputTypeArg = TCTP;
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001258 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001259 ? types::TY_C
1260 : types::TY_CXX;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001261
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001262 arg_iterator it =
1263 Args.filtered_begin(options::OPT__SLASH_TC, options::OPT__SLASH_TP);
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001264 const arg_iterator ie = Args.filtered_end();
1265 Arg *Previous = *it++;
1266 bool ShowNote = false;
1267 while (it != ie) {
Hans Wennborgd9ad0682013-09-11 16:38:41 +00001268 Diag(clang::diag::warn_drv_overriding_flag_option)
1269 << Previous->getSpelling() << (*it)->getSpelling();
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001270 Previous = *it++;
1271 ShowNote = true;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001272 }
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001273 if (ShowNote)
1274 Diag(clang::diag::note_drv_t_option_is_global);
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001275
1276 // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1277 assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1278 }
1279
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001280 for (Arg *A : Args) {
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001281 if (A->getOption().getKind() == Option::InputClass) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001282 const char *Value = A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001283 types::ID Ty = types::TY_INVALID;
1284
1285 // Infer the input type if necessary.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001286 if (InputType == types::TY_Nothing) {
1287 // If there was an explicit arg for this, claim it.
1288 if (InputTypeArg)
1289 InputTypeArg->claim();
1290
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001291 // stdin must be handled specially.
1292 if (memcmp(Value, "-", 2) == 0) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001293 // If running with -E, treat as a C input (this changes the builtin
1294 // macros, for example). This may be overridden by -ObjC below.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001295 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001296 // Otherwise emit an error but still use a valid type to avoid
1297 // spurious errors (e.g., no inputs).
Hans Wennborg70850d82013-07-18 20:29:38 +00001298 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
Hans Wennborgcfdd8b52014-01-29 01:04:40 +00001299 Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1300 : clang::diag::err_drv_unknown_stdin_type);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001301 Ty = types::TY_C;
1302 } else {
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001303 // Otherwise lookup by extension.
1304 // Fallback is C if invoked as C preprocessor or Object otherwise.
1305 // We use a host hook here because Darwin at least has its own
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001306 // idea of what .s is.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001307 if (const char *Ext = strrchr(Value, '.'))
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +00001308 Ty = TC.LookupTypeForExtension(Ext + 1);
Daniel Dunbarea9f0322009-03-20 23:39:23 +00001309
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001310 if (Ty == types::TY_INVALID) {
Hans Wennborg70850d82013-07-18 20:29:38 +00001311 if (CCCIsCPP())
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001312 Ty = types::TY_C;
1313 else
1314 Ty = types::TY_Object;
1315 }
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001316
1317 // If the driver is invoked as C++ compiler (like clang++ or c++) it
1318 // should autodetect some input files as C++ for g++ compatibility.
Hans Wennborg70850d82013-07-18 20:29:38 +00001319 if (CCCIsCXX()) {
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001320 types::ID OldTy = Ty;
1321 Ty = types::lookupCXXTypeForCType(Ty);
1322
1323 if (Ty != OldTy)
1324 Diag(clang::diag::warn_drv_treating_input_as_cxx)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001325 << getTypeName(OldTy) << getTypeName(Ty);
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001326 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001327 }
1328
Daniel Dunbar82b22102009-05-18 21:47:54 +00001329 // -ObjC and -ObjC++ override the default language, but only for "source
1330 // files". We just treat everything that isn't a linker input as a
1331 // source file.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001332 //
Daniel Dunbar82b22102009-05-18 21:47:54 +00001333 // FIXME: Clean this up if we move the phase sequence into the type.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001334 if (Ty != types::TY_Object) {
1335 if (Args.hasArg(options::OPT_ObjC))
1336 Ty = types::TY_ObjC;
1337 else if (Args.hasArg(options::OPT_ObjCXX))
1338 Ty = types::TY_ObjCXX;
1339 }
1340 } else {
1341 assert(InputTypeArg && "InputType set w/o InputTypeArg");
Ehsan Akhgari7e954ea2014-09-12 18:15:10 +00001342 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1343 // If emulating cl.exe, make sure that /TC and /TP don't affect input
1344 // object files.
1345 const char *Ext = strrchr(Value, '.');
1346 if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
1347 Ty = types::TY_Object;
1348 }
1349 if (Ty == types::TY_INVALID) {
1350 Ty = InputType;
1351 InputTypeArg->claim();
1352 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001353 }
1354
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001355 if (DiagnoseInputExistence(*this, Args, Value, Ty))
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001356 Inputs.push_back(std::make_pair(Ty, A));
1357
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001358 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1359 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001360 if (DiagnoseInputExistence(*this, Args, Value, types::TY_C)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001361 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1362 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1363 }
1364 A->claim();
1365 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1366 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001367 if (DiagnoseInputExistence(*this, Args, Value, types::TY_CXX)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001368 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1369 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1370 }
1371 A->claim();
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001372 } else if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001373 // Just treat as object type, we could make a special type for this if
1374 // necessary.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001375 Inputs.push_back(std::make_pair(types::TY_Object, A));
1376
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001377 } else if (A->getOption().matches(options::OPT_x)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001378 InputTypeArg = A;
Richard Smithbd55daf2012-11-01 04:30:05 +00001379 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
Chad Rosier706c2352012-04-07 00:01:31 +00001380 A->claim();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001381
1382 // Follow gcc behavior and treat as linker input for invalid -x
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001383 // options. Its not clear why we shouldn't just revert to unknown; but
Michael J. Spencer1a4fe8c2010-12-17 21:22:33 +00001384 // this isn't very important, we might as well be bug compatible.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001385 if (!InputType) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001386 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001387 InputType = types::TY_Object;
1388 }
1389 }
1390 }
Hans Wennborg70850d82013-07-18 20:29:38 +00001391 if (CCCIsCPP() && Inputs.empty()) {
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001392 // If called as standalone preprocessor, stdin is processed
1393 // if no other input is present.
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001394 Arg *A = MakeInputArg(Args, Opts, "-");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001395 Inputs.push_back(std::make_pair(types::TY_C, A));
1396 }
Chad Rosierecdede82011-08-12 22:08:57 +00001397}
1398
Artem Belevichf8144ab2015-08-27 18:10:41 +00001399// For each unique --cuda-gpu-arch= argument creates a TY_CUDA_DEVICE
1400// input action and then wraps each in CudaDeviceAction paired with
1401// appropriate GPU arch name. In case of partial (i.e preprocessing
1402// only) or device-only compilation, each device action is added to /p
1403// Actions and /p Current is released. Otherwise the function creates
1404// and returns a new CudaHostAction which wraps /p Current and device
1405// side actions.
Justin Lebar41094612016-01-11 23:07:27 +00001406static Action *buildCudaActions(Compilation &C, DerivedArgList &Args,
1407 const Arg *InputArg, Action *HostAction,
1408 ActionList &Actions) {
Justin Lebardc3c5042016-04-19 02:27:07 +00001409 Arg *PartialCompilationArg = Args.getLastArg(
1410 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
1411 options::OPT_cuda_compile_host_device);
1412 bool CompileHostOnly =
1413 PartialCompilationArg &&
1414 PartialCompilationArg->getOption().matches(options::OPT_cuda_host_only);
1415 bool CompileDeviceOnly =
1416 PartialCompilationArg &&
1417 PartialCompilationArg->getOption().matches(options::OPT_cuda_device_only);
Artem Belevichf981e30b2016-08-02 22:37:47 +00001418 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
1419 assert(HostTC && "No toolchain for host compilation.");
1420 if (HostTC->getTriple().isNVPTX()) {
1421 // We do not support targeting NVPTX for host compilation. Throw
1422 // an error and abort pipeline construction early so we don't trip
1423 // asserts that assume device-side compilation.
1424 C.getDriver().Diag(diag::err_drv_cuda_nvptx_host);
1425 return nullptr;
1426 }
Justin Lebardc3c5042016-04-19 02:27:07 +00001427
Samuel Antaod06239d2016-07-15 23:13:27 +00001428 if (CompileHostOnly) {
Artem Belevichf981e30b2016-08-02 22:37:47 +00001429 OffloadAction::HostDependence HDep(*HostAction, *HostTC,
1430 /*BoundArch=*/nullptr, Action::OFK_Cuda);
Samuel Antaod06239d2016-07-15 23:13:27 +00001431 return C.MakeAction<OffloadAction>(HDep);
1432 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001433
1434 // Collect all cuda_gpu_arch parameters, removing duplicates.
Justin Lebar62907612016-07-06 21:21:39 +00001435 SmallVector<CudaArch, 4> GpuArchList;
1436 llvm::SmallSet<CudaArch, 4> GpuArchs;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001437 for (Arg *A : Args) {
Justin Lebar23bcef92016-01-08 19:04:11 +00001438 if (!A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
1439 continue;
1440 A->claim();
Justin Lebar7bf77982016-01-11 23:27:13 +00001441
Justin Lebar62907612016-07-06 21:21:39 +00001442 const auto &ArchStr = A->getValue();
1443 CudaArch Arch = StringToCudaArch(ArchStr);
1444 if (Arch == CudaArch::UNKNOWN)
1445 C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
1446 else if (GpuArchs.insert(Arch).second)
Justin Lebar7bf77982016-01-11 23:27:13 +00001447 GpuArchList.push_back(Arch);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001448 }
1449
1450 // Default to sm_20 which is the lowest common denominator for supported GPUs.
1451 // sm_20 code should work correctly, if suboptimally, on all newer GPUs.
1452 if (GpuArchList.empty())
Justin Lebar62907612016-07-06 21:21:39 +00001453 GpuArchList.push_back(CudaArch::SM_20);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001454
1455 // Replicate inputs for each GPU architecture.
1456 Driver::InputList CudaDeviceInputs;
Artem Belevich5bde4e02015-07-20 20:02:54 +00001457 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001458 CudaDeviceInputs.push_back(std::make_pair(types::TY_CUDA_DEVICE, InputArg));
1459
1460 // Build actions for all device inputs.
1461 ActionList CudaDeviceActions;
Justin Lebar0f3474c2016-02-11 02:00:50 +00001462 C.getDriver().BuildActions(C, Args, CudaDeviceInputs, CudaDeviceActions);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001463 assert(GpuArchList.size() == CudaDeviceActions.size() &&
1464 "Failed to create actions for all devices");
1465
1466 // Check whether any of device actions stopped before they could generate PTX.
Justin Lebar23bcef92016-01-08 19:04:11 +00001467 bool PartialCompilation =
1468 llvm::any_of(CudaDeviceActions, [](const Action *a) {
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001469 return a->getKind() != Action::AssembleJobClass;
Justin Lebar23bcef92016-01-08 19:04:11 +00001470 });
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001471
Samuel Antaod06239d2016-07-15 23:13:27 +00001472 const ToolChain *CudaTC = C.getSingleOffloadToolChain<Action::OFK_Cuda>();
1473
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001474 // Figure out what to do with device actions -- pass them as inputs to the
1475 // host action or run each of them independently.
Justin Lebardc3c5042016-04-19 02:27:07 +00001476 if (PartialCompilation || CompileDeviceOnly) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001477 // In case of partial or device-only compilation results of device actions
1478 // are not consumed by the host action device actions have to be added to
1479 // top-level actions list with AtTopLevel=true and run independently.
1480
1481 // -o is ambiguous if we have more than one top-level action.
1482 if (Args.hasArg(options::OPT_o) &&
Justin Lebardc3c5042016-04-19 02:27:07 +00001483 (!CompileDeviceOnly || GpuArchList.size() > 1)) {
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00001484 C.getDriver().Diag(
1485 clang::diag::err_drv_output_argument_with_multiple_files);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001486 return nullptr;
1487 }
1488
Samuel Antaod06239d2016-07-15 23:13:27 +00001489 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
1490 OffloadAction::DeviceDependences DDep;
1491 DDep.add(*CudaDeviceActions[I], *CudaTC, CudaArchToString(GpuArchList[I]),
1492 Action::OFK_Cuda);
1493 Actions.push_back(
1494 C.MakeAction<OffloadAction>(DDep, CudaDeviceActions[I]->getType()));
1495 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001496 // Kill host action in case of device-only compilation.
Justin Lebardc3c5042016-04-19 02:27:07 +00001497 if (CompileDeviceOnly)
Justin Lebar41094612016-01-11 23:07:27 +00001498 return nullptr;
Artem Belevichdb35a3e2015-07-20 21:59:31 +00001499 return HostAction;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001500 }
Artem Belevich5bde4e02015-07-20 20:02:54 +00001501
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001502 // If we're not a partial or device-only compilation, we compile each arch to
1503 // ptx and assemble to cubin, then feed the cubin *and* the ptx into a device
1504 // "link" action, which uses fatbinary to combine these cubins into one
1505 // fatbin. The fatbin is then an input to the host compilation.
Artem Belevich5bde4e02015-07-20 20:02:54 +00001506 ActionList DeviceActions;
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001507 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
1508 Action* AssembleAction = CudaDeviceActions[I];
1509 assert(AssembleAction->getType() == types::TY_Object);
1510 assert(AssembleAction->getInputs().size() == 1);
1511
1512 Action* BackendAction = AssembleAction->getInputs()[0];
1513 assert(BackendAction->getType() == types::TY_PP_Asm);
1514
Samuel Antaod06239d2016-07-15 23:13:27 +00001515 for (auto &A : {AssembleAction, BackendAction}) {
1516 OffloadAction::DeviceDependences DDep;
1517 DDep.add(*A, *CudaTC, CudaArchToString(GpuArchList[I]), Action::OFK_Cuda);
1518 DeviceActions.push_back(C.MakeAction<OffloadAction>(DDep, A->getType()));
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001519 }
1520 }
Samuel Antaod06239d2016-07-15 23:13:27 +00001521 auto FatbinAction =
1522 C.MakeAction<LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN);
1523
Artem Belevich5bde4e02015-07-20 20:02:54 +00001524 // Return a new host action that incorporates original host action and all
1525 // device actions.
Artem Belevichf981e30b2016-08-02 22:37:47 +00001526 OffloadAction::HostDependence HDep(*HostAction, *HostTC,
1527 /*BoundArch=*/nullptr, Action::OFK_Cuda);
Samuel Antaod06239d2016-07-15 23:13:27 +00001528 OffloadAction::DeviceDependences DDep;
1529 DDep.add(*FatbinAction, *CudaTC, /*BoundArch=*/nullptr, Action::OFK_Cuda);
1530 return C.MakeAction<OffloadAction>(HDep, DDep);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001531}
1532
Justin Lebar0f3474c2016-02-11 02:00:50 +00001533void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
1534 const InputList &Inputs, ActionList &Actions) const {
Chad Rosierecdede82011-08-12 22:08:57 +00001535 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001536
Daniel Dunbar34c41872009-03-13 00:17:48 +00001537 if (!SuppressMissingInputWarning && Inputs.empty()) {
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001538 Diag(clang::diag::err_drv_no_input_files);
1539 return;
1540 }
1541
Chad Rosier7742b5d2011-07-27 23:36:45 +00001542 Arg *FinalPhaseArg;
1543 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001544
Rafael Espindolae8025642013-08-25 14:27:09 +00001545 if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) {
1546 Diag(clang::diag::err_drv_emit_llvm_link);
1547 }
1548
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001549 // Reject -Z* at the top level, these options should never have been exposed
1550 // by gcc.
Daniel Dunbardd765242009-03-26 16:12:09 +00001551 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Daniel Dunbar0e759942009-03-20 06:14:23 +00001552 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001553
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001554 // Diagnose misuse of /Fo.
1555 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001556 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00001557 if (Inputs.size() > 1 && !V.empty() &&
1558 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001559 // Check whether /Fo tries to name an output file for multiple inputs.
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001560 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001561 << A->getSpelling() << V;
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001562 Args.eraseArg(options::OPT__SLASH_Fo);
1563 }
1564 }
1565
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001566 // Diagnose misuse of /Fa.
1567 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
1568 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00001569 if (Inputs.size() > 1 && !V.empty() &&
1570 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001571 // Check whether /Fa tries to name an asm file for multiple inputs.
1572 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001573 << A->getSpelling() << V;
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001574 Args.eraseArg(options::OPT__SLASH_Fa);
1575 }
1576 }
1577
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00001578 // Diagnose misuse of /o.
1579 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
1580 if (A->getValue()[0] == '\0') {
1581 // It has to have a value.
1582 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1583 Args.eraseArg(options::OPT__SLASH_o);
1584 }
1585 }
1586
Nico Weber2ca4be92016-03-01 23:16:44 +00001587 // Diagnose unsupported forms of /Yc /Yu. Ignore /Yc/Yu for now if:
1588 // * no filename after it
1589 // * both /Yc and /Yu passed but with different filenames
1590 // * corresponding file not also passed as /FI
1591 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1592 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1593 if (YcArg && YcArg->getValue()[0] == '\0') {
1594 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
1595 Args.eraseArg(options::OPT__SLASH_Yc);
1596 YcArg = nullptr;
1597 }
1598 if (YuArg && YuArg->getValue()[0] == '\0') {
1599 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
1600 Args.eraseArg(options::OPT__SLASH_Yu);
1601 YuArg = nullptr;
1602 }
1603 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
1604 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
1605 Args.eraseArg(options::OPT__SLASH_Yc);
1606 Args.eraseArg(options::OPT__SLASH_Yu);
1607 YcArg = YuArg = nullptr;
1608 }
1609 if (YcArg || YuArg) {
1610 StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
1611 bool FoundMatchingInclude = false;
1612 for (const Arg *Inc : Args.filtered(options::OPT_include)) {
1613 // FIXME: Do case-insensitive matching and consider / and \ as equal.
1614 if (Inc->getValue() == Val)
1615 FoundMatchingInclude = true;
1616 }
1617 if (!FoundMatchingInclude) {
1618 Diag(clang::diag::warn_drv_ycyu_no_fi_arg_clang_cl)
1619 << (YcArg ? YcArg : YuArg)->getSpelling();
1620 Args.eraseArg(options::OPT__SLASH_Yc);
1621 Args.eraseArg(options::OPT__SLASH_Yu);
1622 YcArg = YuArg = nullptr;
1623 }
1624 }
1625 if (YcArg && Inputs.size() > 1) {
1626 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
1627 Args.eraseArg(options::OPT__SLASH_Yc);
1628 YcArg = nullptr;
1629 }
1630 if (Args.hasArg(options::OPT__SLASH_Y_)) {
1631 // /Y- disables all pch handling. Rather than check for it everywhere,
1632 // just remove clang-cl pch-related flags here.
1633 Args.eraseArg(options::OPT__SLASH_Fp);
1634 Args.eraseArg(options::OPT__SLASH_Yc);
1635 Args.eraseArg(options::OPT__SLASH_Yu);
1636 YcArg = YuArg = nullptr;
1637 }
Nico Weber2ca4be92016-03-01 23:16:44 +00001638
Samuel Antaod06239d2016-07-15 23:13:27 +00001639 // Track the host offload kinds used on this compilation.
1640 unsigned CompilationActiveOffloadHostKinds = 0u;
1641
Daniel Dunbar65229332009-03-13 11:38:42 +00001642 // Construct the actions to perform.
1643 ActionList LinkerInputs;
Alp Toker965f8822013-11-27 05:22:15 +00001644
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001645 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
Artem Belevich5bde4e02015-07-20 20:02:54 +00001646 for (auto &I : Inputs) {
1647 types::ID InputType = I.first;
1648 const Arg *InputArg = I.second;
Daniel Dunbar65229332009-03-13 11:38:42 +00001649
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001650 PL.clear();
1651 types::getCompilationPhases(InputType, PL);
Daniel Dunbar65229332009-03-13 11:38:42 +00001652
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001653 // If the first step comes after the final phase we are doing as part of
1654 // this compilation, warn the user about it.
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001655 phases::ID InitialPhase = PL[0];
Daniel Dunbar65229332009-03-13 11:38:42 +00001656 if (InitialPhase > FinalPhase) {
Daniel Dunbaradc5c7c2009-03-19 07:57:08 +00001657 // Claim here to avoid the more general unused warning.
1658 InputArg->claim();
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001659
Daniel Dunbar2db3e732011-04-20 15:44:48 +00001660 // Suppress all unused style warnings with -Qunused-arguments
1661 if (Args.hasArg(options::OPT_Qunused_arguments))
1662 continue;
1663
Richard Smith403f76e2012-08-06 04:09:06 +00001664 // Special case when final phase determined by binary name, rather than
1665 // by a command-line argument with a corresponding Arg.
Hans Wennborg70850d82013-07-18 20:29:38 +00001666 if (CCCIsCPP())
Richard Smith403f76e2012-08-06 04:09:06 +00001667 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001668 << InputArg->getAsString(Args) << getPhaseName(InitialPhase);
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001669 // Special case '-E' warning on a previously preprocessed file to make
1670 // more sense.
Richard Smith403f76e2012-08-06 04:09:06 +00001671 else if (InitialPhase == phases::Compile &&
1672 FinalPhase == phases::Preprocess &&
1673 getPreprocessedType(InputType) == types::TY_INVALID)
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001674 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001675 << InputArg->getAsString(Args) << !!FinalPhaseArg
1676 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001677 else
1678 Diag(clang::diag::warn_drv_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001679 << InputArg->getAsString(Args) << getPhaseName(InitialPhase)
1680 << !!FinalPhaseArg
1681 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar65229332009-03-13 11:38:42 +00001682 continue;
1683 }
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001684
Nico Weberad2d8f32016-04-21 19:59:10 +00001685 if (YcArg) {
1686 // Add a separate precompile phase for the compile phase.
1687 if (FinalPhase >= phases::Compile) {
Richard Smith8cd452d2016-08-30 18:55:16 +00001688 const types::ID HeaderType = lookupHeaderTypeForSourceType(InputType);
Nico Weberad2d8f32016-04-21 19:59:10 +00001689 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PCHPL;
Richard Smith8cd452d2016-08-30 18:55:16 +00001690 types::getCompilationPhases(HeaderType, PCHPL);
Nico Weberad2d8f32016-04-21 19:59:10 +00001691 Arg *PchInputArg = MakeInputArg(Args, Opts, YcArg->getValue());
1692
1693 // Build the pipeline for the pch file.
Richard Smith8cd452d2016-08-30 18:55:16 +00001694 Action *ClangClPch =
1695 C.MakeAction<InputAction>(*PchInputArg, HeaderType);
Nico Weberad2d8f32016-04-21 19:59:10 +00001696 for (phases::ID Phase : PCHPL)
1697 ClangClPch = ConstructPhaseAction(C, Args, Phase, ClangClPch);
1698 assert(ClangClPch);
1699 Actions.push_back(ClangClPch);
1700 // The driver currently exits after the first failed command. This
1701 // relies on that behavior, to make sure if the pch generation fails,
1702 // the main compilation won't run.
1703 }
1704 }
1705
Justin Lebar23bcef92016-01-08 19:04:11 +00001706 phases::ID CudaInjectionPhase =
1707 (phases::Compile < FinalPhase &&
1708 llvm::find(PL, phases::Compile) != PL.end())
1709 ? phases::Compile
1710 : FinalPhase;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001711
Samuel Antaod06239d2016-07-15 23:13:27 +00001712 // Track the host offload kinds used on this input.
1713 unsigned InputActiveOffloadHostKinds = 0u;
1714
Daniel Dunbar65229332009-03-13 11:38:42 +00001715 // Build the pipeline for this file.
Justin Lebar41094612016-01-11 23:07:27 +00001716 Action *Current = C.MakeAction<InputAction>(*InputArg, InputType);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001717 for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
1718 i != e; ++i) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001719 phases::ID Phase = *i;
Daniel Dunbar65229332009-03-13 11:38:42 +00001720
1721 // We are done if this step is past what the user requested.
1722 if (Phase > FinalPhase)
1723 break;
1724
1725 // Queue linker inputs.
1726 if (Phase == phases::Link) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001727 assert((i + 1) == e && "linking must be final compilation step.");
Justin Lebar41094612016-01-11 23:07:27 +00001728 LinkerInputs.push_back(Current);
1729 Current = nullptr;
Daniel Dunbar65229332009-03-13 11:38:42 +00001730 break;
1731 }
1732
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001733 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1734 // encode this in the steps because the intermediate type depends on
1735 // arguments. Just special case here.
Daniel Dunbar13864952009-03-24 20:17:30 +00001736 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1737 continue;
1738
Daniel Dunbar65229332009-03-13 11:38:42 +00001739 // Otherwise construct the appropriate action.
Justin Lebar0f3474c2016-02-11 02:00:50 +00001740 Current = ConstructPhaseAction(C, Args, Phase, Current);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001741
Artem Belevich23256752015-09-22 17:23:09 +00001742 if (InputType == types::TY_CUDA && Phase == CudaInjectionPhase) {
Justin Lebar41094612016-01-11 23:07:27 +00001743 Current = buildCudaActions(C, Args, InputArg, Current, Actions);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001744 if (!Current)
1745 break;
Samuel Antaod06239d2016-07-15 23:13:27 +00001746
1747 // We produced a CUDA action for this input, so the host has to support
1748 // CUDA.
1749 InputActiveOffloadHostKinds |= Action::OFK_Cuda;
1750 CompilationActiveOffloadHostKinds |= Action::OFK_Cuda;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001751 }
1752
Daniel Dunbar65229332009-03-13 11:38:42 +00001753 if (Current->getType() == types::TY_Nothing)
1754 break;
1755 }
1756
Samuel Antaod06239d2016-07-15 23:13:27 +00001757 // If we ended with something, add to the output list. Also, propagate the
1758 // offload information to the top-level host action related with the current
1759 // input.
1760 if (Current) {
1761 if (InputActiveOffloadHostKinds)
1762 Current->propagateHostOffloadInfo(InputActiveOffloadHostKinds,
1763 /*BoundArch=*/nullptr);
Justin Lebar41094612016-01-11 23:07:27 +00001764 Actions.push_back(Current);
Samuel Antaod06239d2016-07-15 23:13:27 +00001765 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001766 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001767
Samuel Antaod06239d2016-07-15 23:13:27 +00001768 // Add a link action if necessary and propagate the offload information for
1769 // the current compilation.
1770 if (!LinkerInputs.empty()) {
Justin Lebar41094612016-01-11 23:07:27 +00001771 Actions.push_back(
1772 C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image));
Samuel Antaod06239d2016-07-15 23:13:27 +00001773 Actions.back()->propagateHostOffloadInfo(CompilationActiveOffloadHostKinds,
1774 /*BoundArch=*/nullptr);
1775 }
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001776
1777 // If we are linking, claim any options which are obviously only used for
1778 // compilation.
Hans Wennborga8ef14f2013-09-17 00:03:41 +00001779 if (FinalPhase == phases::Link && PL.size() == 1) {
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001780 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
Hans Wennborga8ef14f2013-09-17 00:03:41 +00001781 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
1782 }
1783
1784 // Claim ignored clang-cl options.
1785 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
Artem Belevichbaae0932015-07-28 21:01:30 +00001786
Justin Lebardc3c5042016-04-19 02:27:07 +00001787 // Claim --cuda-host-only and --cuda-compile-host-device, which may be passed
1788 // to non-CUDA compilations and should not trigger warnings there.
Artem Belevichbaae0932015-07-28 21:01:30 +00001789 Args.ClaimAllArgs(options::OPT_cuda_host_only);
Justin Lebardc3c5042016-04-19 02:27:07 +00001790 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
Daniel Dunbar65229332009-03-13 11:38:42 +00001791}
1792
Justin Lebar0f3474c2016-02-11 02:00:50 +00001793Action *Driver::ConstructPhaseAction(Compilation &C, const ArgList &Args,
1794 phases::ID Phase, Action *Input) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001795 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
Daniel Dunbar65229332009-03-13 11:38:42 +00001796 // Build the appropriate action.
1797 switch (Phase) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001798 case phases::Link:
1799 llvm_unreachable("link action invalid here.");
Daniel Dunbar65229332009-03-13 11:38:42 +00001800 case phases::Preprocess: {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001801 types::ID OutputTy;
1802 // -{M, MM} alter the output type.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +00001803 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001804 OutputTy = types::TY_Dependencies;
1805 } else {
David Blaikie5d577a22012-06-29 22:03:56 +00001806 OutputTy = Input->getType();
1807 if (!Args.hasFlag(options::OPT_frewrite_includes,
Justin Bognerce8245b2014-06-24 08:01:01 +00001808 options::OPT_fno_rewrite_includes, false) &&
1809 !CCGenDiagnostics)
David Blaikie5d577a22012-06-29 22:03:56 +00001810 OutputTy = types::getPreprocessedType(OutputTy);
Daniel Dunbard67a3222009-03-30 06:36:42 +00001811 assert(OutputTy != types::TY_INVALID &&
1812 "Cannot preprocess this input type!");
1813 }
Justin Lebar41094612016-01-11 23:07:27 +00001814 return C.MakeAction<PreprocessJobAction>(Input, OutputTy);
Daniel Dunbar65229332009-03-13 11:38:42 +00001815 }
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001816 case phases::Precompile: {
Richard Smith8cd452d2016-08-30 18:55:16 +00001817 assert(onlyPrecompileType(Input->getType()) &&
1818 "asked to precompile non-precompilable type");
Nico Webere36ab4a2016-08-30 14:12:06 +00001819 types::ID OutputTy = types::TY_PCH;
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001820 if (Args.hasArg(options::OPT_fsyntax_only)) {
1821 // Syntax checks should not emit a PCH file
1822 OutputTy = types::TY_Nothing;
1823 }
Justin Lebar41094612016-01-11 23:07:27 +00001824 return C.MakeAction<PrecompileJobAction>(Input, OutputTy);
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001825 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001826 case phases::Compile: {
David Blaikie486f4402014-08-29 07:25:23 +00001827 if (Args.hasArg(options::OPT_fsyntax_only))
Justin Lebar41094612016-01-11 23:07:27 +00001828 return C.MakeAction<CompileJobAction>(Input, types::TY_Nothing);
David Blaikie486f4402014-08-29 07:25:23 +00001829 if (Args.hasArg(options::OPT_rewrite_objc))
Justin Lebar41094612016-01-11 23:07:27 +00001830 return C.MakeAction<CompileJobAction>(Input, types::TY_RewrittenObjC);
David Blaikie486f4402014-08-29 07:25:23 +00001831 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
Justin Lebar41094612016-01-11 23:07:27 +00001832 return C.MakeAction<CompileJobAction>(Input,
1833 types::TY_RewrittenLegacyObjC);
David Blaikie486f4402014-08-29 07:25:23 +00001834 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
Justin Lebar41094612016-01-11 23:07:27 +00001835 return C.MakeAction<AnalyzeJobAction>(Input, types::TY_Plist);
David Blaikie486f4402014-08-29 07:25:23 +00001836 if (Args.hasArg(options::OPT__migrate))
Justin Lebar41094612016-01-11 23:07:27 +00001837 return C.MakeAction<MigrateJobAction>(Input, types::TY_Remap);
David Blaikie486f4402014-08-29 07:25:23 +00001838 if (Args.hasArg(options::OPT_emit_ast))
Justin Lebar41094612016-01-11 23:07:27 +00001839 return C.MakeAction<CompileJobAction>(Input, types::TY_AST);
David Blaikie486f4402014-08-29 07:25:23 +00001840 if (Args.hasArg(options::OPT_module_file_info))
Justin Lebar41094612016-01-11 23:07:27 +00001841 return C.MakeAction<CompileJobAction>(Input, types::TY_ModuleFile);
David Blaikie486f4402014-08-29 07:25:23 +00001842 if (Args.hasArg(options::OPT_verify_pch))
Justin Lebar41094612016-01-11 23:07:27 +00001843 return C.MakeAction<VerifyPCHJobAction>(Input, types::TY_Nothing);
1844 return C.MakeAction<CompileJobAction>(Input, types::TY_LLVM_BC);
Bob Wilson23a55f12014-12-21 07:00:00 +00001845 }
1846 case phases::Backend: {
Teresa Johnson945bc502015-10-15 20:35:53 +00001847 if (isUsingLTO()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001848 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001849 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
Justin Lebar41094612016-01-11 23:07:27 +00001850 return C.MakeAction<BackendJobAction>(Input, Output);
David Blaikie486f4402014-08-29 07:25:23 +00001851 }
1852 if (Args.hasArg(options::OPT_emit_llvm)) {
Shuxin Yang4b3c7ff2013-08-23 21:34:57 +00001853 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001854 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
Justin Lebar41094612016-01-11 23:07:27 +00001855 return C.MakeAction<BackendJobAction>(Input, Output);
Daniel Dunbar65229332009-03-13 11:38:42 +00001856 }
Justin Lebar41094612016-01-11 23:07:27 +00001857 return C.MakeAction<BackendJobAction>(Input, types::TY_PP_Asm);
Daniel Dunbar65229332009-03-13 11:38:42 +00001858 }
1859 case phases::Assemble:
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001860 return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object);
Daniel Dunbar65229332009-03-13 11:38:42 +00001861 }
1862
David Blaikie83d382b2011-09-23 05:06:16 +00001863 llvm_unreachable("invalid phase in ConstructPhaseAction");
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001864}
1865
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001866void Driver::BuildJobs(Compilation &C) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001867 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001868
1869 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1870
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001871 // It is an error to provide a -o option if we are making multiple output
1872 // files.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001873 if (FinalOutput) {
1874 unsigned NumOutputs = 0;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00001875 for (const Action *A : C.getActions())
1876 if (A->getType() != types::TY_Nothing)
Daniel Dunbare75d8342009-03-16 06:56:51 +00001877 ++NumOutputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001878
Daniel Dunbare75d8342009-03-16 06:56:51 +00001879 if (NumOutputs > 1) {
1880 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
Craig Topper92fc2df2014-05-17 16:56:41 +00001881 FinalOutput = nullptr;
Daniel Dunbare75d8342009-03-16 06:56:51 +00001882 }
1883 }
1884
Chad Rosier35767232013-04-30 22:01:21 +00001885 // Collect the list of architectures.
1886 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001887 if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO())
1888 for (const Arg *A : C.getArgs())
Chad Rosier35767232013-04-30 22:01:21 +00001889 if (A->getOption().matches(options::OPT_arch))
1890 ArchNames.insert(A->getValue());
Chad Rosier35767232013-04-30 22:01:21 +00001891
Justin Lebarb44f6fe2016-01-14 21:41:21 +00001892 // Set of (Action, canonical ToolChain triple) pairs we've built jobs for.
1893 std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001894 for (Action *A : C.getActions()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001895 // If we are linking an image for multiple archs then the linker wants
1896 // -arch_multiple and -final_output <final image name>. Unfortunately, this
1897 // doesn't fit in cleanly because we have to pass this information down.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001898 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001899 // FIXME: This is a hack; find a cleaner way to integrate this into the
1900 // process.
Craig Topper92fc2df2014-05-17 16:56:41 +00001901 const char *LinkingOutput = nullptr;
Daniel Dunbardd765242009-03-26 16:12:09 +00001902 if (isa<LipoJobAction>(A)) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001903 if (FinalOutput)
Richard Smithbd55daf2012-11-01 04:30:05 +00001904 LinkingOutput = FinalOutput->getValue();
Daniel Dunbare75d8342009-03-16 06:56:51 +00001905 else
Hans Wennborga7707222015-01-09 17:38:53 +00001906 LinkingOutput = getDefaultImageName();
Daniel Dunbare75d8342009-03-16 06:56:51 +00001907 }
1908
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001909 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001910 /*BoundArch*/ nullptr,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001911 /*AtTopLevel*/ true,
Chad Rosier35767232013-04-30 22:01:21 +00001912 /*MultipleArchs*/ ArchNames.size() > 1,
Samuel Antaod06239d2016-07-15 23:13:27 +00001913 /*LinkingOutput*/ LinkingOutput, CachedResults,
1914 /*BuildForOffloadDevice*/ false);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001915 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001916
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001917 // If the user passed -Qunused-arguments or there were errors, don't warn
1918 // about any unused arguments.
Argyrios Kyrtzidis31448a42010-11-18 21:47:07 +00001919 if (Diags.hasErrorOccurred() ||
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001920 C.getArgs().hasArg(options::OPT_Qunused_arguments))
Daniel Dunbard175d972009-03-18 18:03:46 +00001921 return;
1922
Daniel Dunbar58399ae2009-03-29 22:24:54 +00001923 // Claim -### here.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001924 (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001925
Nico Weber47bf5052016-04-25 21:15:49 +00001926 // Claim --driver-mode, --rsp-quoting, it was handled earlier.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001927 (void)C.getArgs().hasArg(options::OPT_driver_mode);
Nico Weber47bf5052016-04-25 21:15:49 +00001928 (void)C.getArgs().hasArg(options::OPT_rsp_quoting);
Hans Wennborg70850d82013-07-18 20:29:38 +00001929
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001930 for (Arg *A : C.getArgs()) {
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001931 // FIXME: It would be nice to be able to send the argument to the
David Blaikie9c902b52011-09-25 23:23:43 +00001932 // DiagnosticsEngine, so that extra values, position, and so on could be
1933 // printed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001934 if (!A->isClaimed()) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001935 if (A->getOption().hasFlag(options::NoArgumentUnused))
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001936 continue;
1937
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001938 // Suppress the warning automatically if this is just a flag, and it is an
1939 // instance of an argument we already claimed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001940 const Option &Opt = A->getOption();
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001941 if (Opt.getKind() == Option::FlagClass) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001942 bool DuplicateClaimed = false;
1943
Sean Silva14facf32015-06-09 01:57:17 +00001944 for (const Arg *AA : C.getArgs().filtered(&Opt)) {
1945 if (AA->isClaimed()) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001946 DuplicateClaimed = true;
1947 break;
1948 }
1949 }
1950
1951 if (DuplicateClaimed)
1952 continue;
1953 }
1954
Ehsan Akhgarid8518332016-01-25 21:14:52 +00001955 // In clang-cl, don't mention unknown arguments here since they have
1956 // already been warned about.
1957 if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
1958 Diag(clang::diag::warn_drv_unused_argument)
1959 << A->getAsString(C.getArgs());
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001960 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001961 }
Daniel Dunbar95e6b192009-03-13 22:12:33 +00001962}
Samuel Antaod06239d2016-07-15 23:13:27 +00001963/// Collapse an offloading action looking for a job of the given type. The input
1964/// action is changed to the input of the collapsed sequence. If we effectively
1965/// had a collapse return the corresponding offloading action, otherwise return
1966/// null.
1967template <typename T>
1968static OffloadAction *collapseOffloadingAction(Action *&CurAction) {
1969 if (!CurAction)
1970 return nullptr;
1971 if (auto *OA = dyn_cast<OffloadAction>(CurAction)) {
1972 if (OA->hasHostDependence())
1973 if (auto *HDep = dyn_cast<T>(OA->getHostDependence())) {
1974 CurAction = HDep;
1975 return OA;
1976 }
1977 if (OA->hasSingleDeviceDependence())
1978 if (auto *DDep = dyn_cast<T>(OA->getSingleDeviceDependence())) {
1979 CurAction = DDep;
1980 return OA;
1981 }
1982 }
1983 return nullptr;
1984}
Artem Belevichf8144ab2015-08-27 18:10:41 +00001985// Returns a Tool for a given JobAction. In case the action and its
1986// predecessors can be combined, updates Inputs with the inputs of the
1987// first combined action. If one of the collapsed actions is a
1988// CudaHostAction, updates CollapsedCHA with the pointer to it so the
1989// caller can deal with extra handling such action requires.
1990static const Tool *selectToolForJob(Compilation &C, bool SaveTemps,
Steven Wu574b0f22016-03-01 01:07:58 +00001991 bool EmbedBitcode, const ToolChain *TC,
1992 const JobAction *JA,
Artem Belevichf8144ab2015-08-27 18:10:41 +00001993 const ActionList *&Inputs,
Samuel Antaod06239d2016-07-15 23:13:27 +00001994 ActionList &CollapsedOffloadAction) {
Craig Topper92fc2df2014-05-17 16:56:41 +00001995 const Tool *ToolForJob = nullptr;
Samuel Antaod06239d2016-07-15 23:13:27 +00001996 CollapsedOffloadAction.clear();
Daniel Dunbarc4343942010-02-03 03:07:56 +00001997
1998 // See if we should look for a compiler with an integrated assembler. We match
1999 // bottom up, so what we are actually looking for is an assembler job with a
Reid Klecknerda0acc82014-12-18 23:07:04 +00002000 // compiler input.
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00002001
Samuel Antaod06239d2016-07-15 23:13:27 +00002002 // Look through offload actions between assembler and backend actions.
2003 Action *BackendJA = (isa<AssembleJobAction>(JA) && Inputs->size() == 1)
2004 ? *Inputs->begin()
2005 : nullptr;
2006 auto *BackendOA = collapseOffloadingAction<BackendJobAction>(BackendJA);
2007
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002008 if (TC->useIntegratedAs() && !SaveTemps &&
David Peixotto3e325d72013-12-06 20:27:33 +00002009 !C.getArgs().hasArg(options::OPT_via_file_asm) &&
Hans Wennborg2c21f742013-10-17 16:16:23 +00002010 !C.getArgs().hasArg(options::OPT__SLASH_FA) &&
Samuel Antaod06239d2016-07-15 23:13:27 +00002011 !C.getArgs().hasArg(options::OPT__SLASH_Fa) && BackendJA &&
2012 isa<BackendJobAction>(BackendJA)) {
Steven Wu574b0f22016-03-01 01:07:58 +00002013 // A BackendJob is always preceded by a CompileJob, and without -save-temps
2014 // or -fembed-bitcode, they will always get combined together, so instead of
2015 // checking the backend tool, check if the tool for the CompileJob has an
2016 // integrated assembler. For -fembed-bitcode, CompileJob is still used to
2017 // look up tools for BackendJob, but they need to match before we can split
2018 // them.
Samuel Antaod06239d2016-07-15 23:13:27 +00002019
2020 // Look through offload actions between backend and compile actions.
2021 Action *CompileJA = *BackendJA->getInputs().begin();
2022 auto *CompileOA = collapseOffloadingAction<CompileJobAction>(CompileJA);
2023
2024 assert(CompileJA && isa<CompileJobAction>(CompileJA) &&
2025 "Backend job is not preceeded by compile job.");
2026 const Tool *Compiler = TC->SelectTool(*cast<CompileJobAction>(CompileJA));
Rafael Espindola79764462013-03-24 15:06:53 +00002027 if (!Compiler)
Craig Topper92fc2df2014-05-17 16:56:41 +00002028 return nullptr;
Steven Wu574b0f22016-03-01 01:07:58 +00002029 // When using -fembed-bitcode, it is required to have the same tool (clang)
2030 // for both CompilerJA and BackendJA. Otherwise, combine two stages.
2031 if (EmbedBitcode) {
2032 JobAction *InputJA = cast<JobAction>(*Inputs->begin());
2033 const Tool *BackendTool = TC->SelectTool(*InputJA);
2034 if (BackendTool == Compiler)
2035 CompileJA = InputJA;
2036 }
Rafael Espindola79764462013-03-24 15:06:53 +00002037 if (Compiler->hasIntegratedAssembler()) {
Artem Belevichf8144ab2015-08-27 18:10:41 +00002038 Inputs = &CompileJA->getInputs();
Bob Wilson23a55f12014-12-21 07:00:00 +00002039 ToolForJob = Compiler;
Samuel Antaod06239d2016-07-15 23:13:27 +00002040 // Save the collapsed offload actions because they may still contain
2041 // device actions.
2042 if (CompileOA)
2043 CollapsedOffloadAction.push_back(CompileOA);
2044 if (BackendOA)
2045 CollapsedOffloadAction.push_back(BackendOA);
Bob Wilson23a55f12014-12-21 07:00:00 +00002046 }
2047 }
2048
2049 // A backend job should always be combined with the preceding compile job
Steven Wu574b0f22016-03-01 01:07:58 +00002050 // unless OPT_save_temps or OPT_fembed_bitcode is enabled and the compiler is
2051 // capable of emitting LLVM IR as an intermediate output.
Bob Wilson23a55f12014-12-21 07:00:00 +00002052 if (isa<BackendJobAction>(JA)) {
2053 // Check if the compiler supports emitting LLVM IR.
2054 assert(Inputs->size() == 1);
Samuel Antaod06239d2016-07-15 23:13:27 +00002055
2056 // Look through offload actions between backend and compile actions.
2057 Action *CompileJA = *JA->getInputs().begin();
2058 auto *CompileOA = collapseOffloadingAction<CompileJobAction>(CompileJA);
2059
2060 assert(CompileJA && isa<CompileJobAction>(CompileJA) &&
2061 "Backend job is not preceeded by compile job.");
2062 const Tool *Compiler = TC->SelectTool(*cast<CompileJobAction>(CompileJA));
Bob Wilson23a55f12014-12-21 07:00:00 +00002063 if (!Compiler)
2064 return nullptr;
Steven Wu574b0f22016-03-01 01:07:58 +00002065 if (!Compiler->canEmitIR() ||
2066 (!SaveTemps && !EmbedBitcode)) {
Artem Belevichf8144ab2015-08-27 18:10:41 +00002067 Inputs = &CompileJA->getInputs();
Rafael Espindola79764462013-03-24 15:06:53 +00002068 ToolForJob = Compiler;
Samuel Antaod06239d2016-07-15 23:13:27 +00002069
2070 if (CompileOA)
2071 CollapsedOffloadAction.push_back(CompileOA);
Daniel Dunbarc4343942010-02-03 03:07:56 +00002072 }
2073 }
2074
2075 // Otherwise use the tool for the current job.
2076 if (!ToolForJob)
Rafael Espindola79764462013-03-24 15:06:53 +00002077 ToolForJob = TC->SelectTool(*JA);
Daniel Dunbarc4343942010-02-03 03:07:56 +00002078
2079 // See if we should use an integrated preprocessor. We do so when we have
2080 // exactly one input, since this is the only use case we care about
2081 // (irrelevant since we don't support combine yet).
Samuel Antaod06239d2016-07-15 23:13:27 +00002082
2083 // Look through offload actions after preprocessing.
2084 Action *PreprocessJA = (Inputs->size() == 1) ? *Inputs->begin() : nullptr;
2085 auto *PreprocessOA =
2086 collapseOffloadingAction<PreprocessJobAction>(PreprocessJA);
2087
2088 if (PreprocessJA && isa<PreprocessJobAction>(PreprocessJA) &&
Daniel Dunbarc4343942010-02-03 03:07:56 +00002089 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002090 !C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00002091 !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
Samuel Antaod06239d2016-07-15 23:13:27 +00002092 ToolForJob->hasIntegratedCPP()) {
2093 Inputs = &PreprocessJA->getInputs();
2094 if (PreprocessOA)
2095 CollapsedOffloadAction.push_back(PreprocessOA);
2096 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002097
Rafael Espindola79764462013-03-24 15:06:53 +00002098 return ToolForJob;
Daniel Dunbarc4343942010-02-03 03:07:56 +00002099}
2100
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002101InputInfo Driver::BuildJobsForAction(
2102 Compilation &C, const Action *A, const ToolChain *TC, const char *BoundArch,
2103 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
Samuel Antaod06239d2016-07-15 23:13:27 +00002104 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
2105 bool BuildForOffloadDevice) const {
Justin Lebar55c83322016-01-16 03:30:08 +00002106 // The bound arch is not necessarily represented in the toolchain's triple --
2107 // for example, armv7 and armv7s both map to the same triple -- so we need
2108 // both in our map.
2109 std::string TriplePlusArch = TC->getTriple().normalize();
2110 if (BoundArch) {
2111 TriplePlusArch += "-";
2112 TriplePlusArch += BoundArch;
2113 }
2114 std::pair<const Action *, std::string> ActionTC = {A, TriplePlusArch};
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002115 auto CachedResult = CachedResults.find(ActionTC);
2116 if (CachedResult != CachedResults.end()) {
2117 return CachedResult->second;
2118 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002119 InputInfo Result = BuildJobsForActionNoCache(
2120 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
2121 CachedResults, BuildForOffloadDevice);
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002122 CachedResults[ActionTC] = Result;
2123 return Result;
2124}
2125
2126InputInfo Driver::BuildJobsForActionNoCache(
2127 Compilation &C, const Action *A, const ToolChain *TC, const char *BoundArch,
2128 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
Samuel Antaod06239d2016-07-15 23:13:27 +00002129 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
2130 bool BuildForOffloadDevice) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002131 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbarc4acf9d2009-03-18 23:18:19 +00002132
Samuel Antaod06239d2016-07-15 23:13:27 +00002133 InputInfoList OffloadDependencesInputInfo;
2134 if (const OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
2135 // The offload action is expected to be used in four different situations.
2136 //
2137 // a) Set a toolchain/architecture/kind for a host action:
2138 // Host Action 1 -> OffloadAction -> Host Action 2
2139 //
2140 // b) Set a toolchain/architecture/kind for a device action;
2141 // Device Action 1 -> OffloadAction -> Device Action 2
2142 //
2143 // c) Specify a device dependences to a host action;
2144 // Device Action 1 _
2145 // \
2146 // Host Action 1 ---> OffloadAction -> Host Action 2
2147 //
2148 // d) Specify a host dependence to a device action.
2149 // Host Action 1 _
2150 // \
2151 // Device Action 1 ---> OffloadAction -> Device Action 2
2152 //
2153 // For a) and b), we just return the job generated for the dependence. For
2154 // c) and d) we override the current action with the host/device dependence
2155 // if the current toolchain is host/device and set the offload dependences
2156 // info with the jobs obtained from the device/host dependence(s).
2157
2158 // If there is a single device option, just generate the job for it.
2159 if (OA->hasSingleDeviceDependence()) {
2160 InputInfo DevA;
2161 OA->doOnEachDeviceDependence([&](Action *DepA, const ToolChain *DepTC,
2162 const char *DepBoundArch) {
2163 DevA =
2164 BuildJobsForAction(C, DepA, DepTC, DepBoundArch, AtTopLevel,
2165 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput,
2166 CachedResults, /*BuildForOffloadDevice=*/true);
2167 });
2168 return DevA;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002169 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002170
2171 // If 'Action 2' is host, we generate jobs for the device dependences and
2172 // override the current action with the host dependence. Otherwise, we
2173 // generate the host dependences and override the action with the device
2174 // dependence. The dependences can't therefore be a top-level action.
2175 OA->doOnEachDependence(
2176 /*IsHostDependence=*/BuildForOffloadDevice,
2177 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
2178 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
2179 C, DepA, DepTC, DepBoundArch, /*AtTopLevel=*/false,
2180 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput, CachedResults,
2181 /*BuildForOffloadDevice=*/DepA->getOffloadingDeviceKind() !=
2182 Action::OFK_None));
2183 });
2184
2185 A = BuildForOffloadDevice
2186 ? OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)
2187 : OA->getHostDependence();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002188 }
2189
Daniel Dunbare75d8342009-03-16 06:56:51 +00002190 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002191 // FIXME: It would be nice to not claim this here; maybe the old scheme of
2192 // just using Args was better?
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00002193 const Arg &Input = IA->getInputArg();
2194 Input.claim();
Daniel Dunbar35cbfeb2010-06-09 22:31:08 +00002195 if (Input.getOption().matches(options::OPT_INPUT)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002196 const char *Name = Input.getValue();
Justin Lebard98cea82016-01-11 23:15:21 +00002197 return InputInfo(A, Name, /* BaseInput = */ Name);
Douglas Katzman678d0cb2015-06-16 18:01:24 +00002198 }
Justin Lebard98cea82016-01-11 23:15:21 +00002199 return InputInfo(A, &Input, /* BaseInput = */ "");
Daniel Dunbare75d8342009-03-16 06:56:51 +00002200 }
2201
2202 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
Chad Rosiera78a6eb2012-04-27 16:50:38 +00002203 const ToolChain *TC;
Chad Rosier631fa102012-04-27 16:48:16 +00002204 const char *ArchName = BAA->getArchName();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00002205
Chad Rosier631fa102012-04-27 16:48:16 +00002206 if (ArchName)
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +00002207 TC = &getToolChain(C.getArgs(),
2208 computeTargetTriple(*this, DefaultTargetTriple,
2209 C.getArgs(), ArchName));
Chad Rosiera78a6eb2012-04-27 16:50:38 +00002210 else
2211 TC = &C.getDefaultToolChain();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00002212
Nico Weber5a459f82016-02-23 19:30:43 +00002213 return BuildJobsForAction(C, *BAA->input_begin(), TC, ArchName, AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00002214 MultipleArchs, LinkingOutput, CachedResults,
2215 BuildForOffloadDevice);
Daniel Dunbare75d8342009-03-16 06:56:51 +00002216 }
2217
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002218
Daniel Dunbare75d8342009-03-16 06:56:51 +00002219 const ActionList *Inputs = &A->getInputs();
Daniel Dunbarc4343942010-02-03 03:07:56 +00002220
2221 const JobAction *JA = cast<JobAction>(A);
Samuel Antaod06239d2016-07-15 23:13:27 +00002222 ActionList CollapsedOffloadActions;
2223
Artem Belevichf8144ab2015-08-27 18:10:41 +00002224 const Tool *T =
Steven Wu574b0f22016-03-01 01:07:58 +00002225 selectToolForJob(C, isSaveTempsEnabled(), embedBitcodeEnabled(), TC, JA,
Samuel Antaod06239d2016-07-15 23:13:27 +00002226 Inputs, CollapsedOffloadActions);
Rafael Espindola79764462013-03-24 15:06:53 +00002227 if (!T)
Justin Lebar9eaa4892016-01-11 23:09:32 +00002228 return InputInfo();
Daniel Dunbare75d8342009-03-16 06:56:51 +00002229
Samuel Antaod06239d2016-07-15 23:13:27 +00002230 // If we've collapsed action list that contained OffloadAction we
2231 // need to build jobs for host/device-side inputs it may have held.
2232 for (const auto *OA : CollapsedOffloadActions)
2233 cast<OffloadAction>(OA)->doOnEachDependence(
2234 /*IsHostDependence=*/BuildForOffloadDevice,
2235 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
2236 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
Artem Belevichbee2f412016-08-22 18:50:34 +00002237 C, DepA, DepTC, DepBoundArch, /* AtTopLevel */ false,
Samuel Antaod06239d2016-07-15 23:13:27 +00002238 /*MultipleArchs=*/!!DepBoundArch, LinkingOutput, CachedResults,
2239 /*BuildForOffloadDevice=*/DepA->getOffloadingDeviceKind() !=
2240 Action::OFK_None));
2241 });
Artem Belevichf8144ab2015-08-27 18:10:41 +00002242
Daniel Dunbare75d8342009-03-16 06:56:51 +00002243 // Only use pipes when there is exactly one input.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002244 InputInfoList InputInfos;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00002245 for (const Action *Input : *Inputs) {
Eric Christopher14668dd2013-02-18 00:38:25 +00002246 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
2247 // shouldn't get temporary output names.
Daniel Dunbar6beaf512010-06-04 18:28:41 +00002248 // FIXME: Clean this up.
Justin Lebar9eaa4892016-01-11 23:09:32 +00002249 bool SubJobAtTopLevel =
2250 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
Samuel Antaod06239d2016-07-15 23:13:27 +00002251 InputInfos.push_back(BuildJobsForAction(
2252 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
2253 CachedResults, BuildForOffloadDevice));
Daniel Dunbare75d8342009-03-16 06:56:51 +00002254 }
2255
Daniel Dunbare75d8342009-03-16 06:56:51 +00002256 // Always use the first input as the base input.
2257 const char *BaseInput = InputInfos[0].getBaseInput();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002258
Daniel Dunbar6beaf512010-06-04 18:28:41 +00002259 // ... except dsymutil actions, which use their actual input as the base
2260 // input.
2261 if (JA->getType() == types::TY_dSYM)
2262 BaseInput = InputInfos[0].getFilename();
2263
Samuel Antaod06239d2016-07-15 23:13:27 +00002264 // Append outputs of offload device jobs to the input list
2265 if (!OffloadDependencesInputInfo.empty())
2266 InputInfos.append(OffloadDependencesInputInfo.begin(),
2267 OffloadDependencesInputInfo.end());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002268
Vedant Kumar18286cf2016-07-27 23:02:20 +00002269 // Set the effective triple of the toolchain for the duration of this job.
2270 llvm::Triple EffectiveTriple;
2271 const ToolChain &ToolTC = T->getToolChain();
2272 const ArgList &Args = C.getArgsForToolChain(TC, BoundArch);
2273 if (InputInfos.size() != 1) {
2274 EffectiveTriple = llvm::Triple(ToolTC.ComputeEffectiveClangTriple(Args));
2275 } else {
2276 // Pass along the input type if it can be unambiguously determined.
2277 EffectiveTriple = llvm::Triple(
2278 ToolTC.ComputeEffectiveClangTriple(Args, InputInfos[0].getType()));
2279 }
2280 RegisterEffectiveTriple TripleRAII(ToolTC, EffectiveTriple);
2281
Daniel Dunbard00272f2010-08-02 02:38:15 +00002282 // Determine the place to write output to, if any.
Justin Lebar9eaa4892016-01-11 23:09:32 +00002283 InputInfo Result;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002284 if (JA->getType() == types::TY_Nothing)
Justin Lebard98cea82016-01-11 23:15:21 +00002285 Result = InputInfo(A, BaseInput);
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002286 else
Justin Lebard98cea82016-01-11 23:15:21 +00002287 Result = InputInfo(A, GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
Samuel Antaod06239d2016-07-15 23:13:27 +00002288 AtTopLevel, MultipleArchs,
2289 TC->getTriple().normalize()),
Justin Lebard98cea82016-01-11 23:15:21 +00002290 BaseInput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002291
Chad Rosierbe10f982011-08-02 17:58:04 +00002292 if (CCCPrintBindings && !CCGenDiagnostics) {
Rafael Espindola79764462013-03-24 15:06:53 +00002293 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
2294 << " - \"" << T->getName() << "\", inputs: [";
Daniel Dunbarb39cc522009-03-17 22:47:06 +00002295 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
2296 llvm::errs() << InputInfos[i].getAsString();
2297 if (i + 1 != e)
2298 llvm::errs() << ", ";
2299 }
2300 llvm::errs() << "], output: " << Result.getAsString() << "\n";
2301 } else {
Vedant Kumar5fb00e42016-07-27 23:01:55 +00002302 T->ConstructJob(C, *JA, Result, InputInfos,
Rafael Espindola79764462013-03-24 15:06:53 +00002303 C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
Daniel Dunbarb39cc522009-03-17 22:47:06 +00002304 }
Justin Lebar9eaa4892016-01-11 23:09:32 +00002305 return Result;
Daniel Dunbare75d8342009-03-16 06:56:51 +00002306}
2307
Hans Wennborga7707222015-01-09 17:38:53 +00002308const char *Driver::getDefaultImageName() const {
2309 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
2310 return Target.isOSWindows() ? "a.exe" : "a.out";
2311}
2312
Hans Wennborg2c21f742013-10-17 16:16:23 +00002313/// \brief Create output filename based on ArgValue, which could either be a
2314/// full filename, filename without extension, or a directory. If ArgValue
2315/// does not provide a filename, then use BaseName, and use the extension
2316/// suitable for FileType.
Hans Wennborg207fcf02013-08-12 21:56:42 +00002317static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002318 StringRef BaseName,
2319 types::ID FileType) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002320 SmallString<128> Filename = ArgValue;
Justin Bogner5aaf2e72014-06-26 20:59:36 +00002321
Hans Wennborgf1a74252013-09-10 20:18:04 +00002322 if (ArgValue.empty()) {
2323 // If the argument is empty, output to BaseName in the current dir.
2324 Filename = BaseName;
2325 } else if (llvm::sys::path::is_separator(Filename.back())) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002326 // If the argument is a directory, output to BaseName in that dir.
2327 llvm::sys::path::append(Filename, BaseName);
2328 }
2329
2330 if (!llvm::sys::path::has_extension(ArgValue)) {
2331 // If the argument didn't provide an extension, then set it.
2332 const char *Extension = types::getTypeTempSuffix(FileType, true);
Hans Wennborgf1a74252013-09-10 20:18:04 +00002333
2334 if (FileType == types::TY_Image &&
2335 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
2336 // The output file is a dll.
2337 Extension = "dll";
2338 }
2339
Hans Wennborg207fcf02013-08-12 21:56:42 +00002340 llvm::sys::path::replace_extension(Filename, Extension);
2341 }
2342
2343 return Args.MakeArgString(Filename.c_str());
2344}
2345
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002346const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002347 const char *BaseInput,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002348 const char *BoundArch, bool AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00002349 bool MultipleArchs,
2350 StringRef NormalizedTriple) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00002351 llvm::PrettyStackTraceString CrashInfo("Computing output path");
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002352 // Output to a user requested destination?
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002353 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002354 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
Chad Rosier633dcdc2013-01-24 19:14:47 +00002355 return C.addResultFile(FinalOutput->getValue(), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002356 }
2357
Hans Wennborge0053472013-12-20 18:40:46 +00002358 // For /P, preprocess to file named after BaseInput.
2359 if (C.getArgs().hasArg(options::OPT__SLASH_P)) {
2360 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
2361 StringRef BaseName = llvm::sys::path::filename(BaseInput);
Hans Wennborg04c764f2014-06-17 00:19:12 +00002362 StringRef NameArg;
Greg Bedwell065f70a2015-06-09 10:24:06 +00002363 if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi))
Hans Wennborg04c764f2014-06-17 00:19:12 +00002364 NameArg = A->getValue();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002365 return C.addResultFile(
2366 MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, types::TY_PP_C),
2367 &JA);
Hans Wennborge0053472013-12-20 18:40:46 +00002368 }
2369
Nick Lewycky6e1ce292010-09-24 00:46:53 +00002370 // Default to writing to stdout?
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002371 if (AtTopLevel && !CCGenDiagnostics &&
2372 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
Nick Lewycky6e1ce292010-09-24 00:46:53 +00002373 return "-";
2374
Hans Wennborg2c21f742013-10-17 16:16:23 +00002375 // Is this the assembly listing for /FA?
2376 if (JA.getType() == types::TY_PP_Asm &&
2377 (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
2378 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
2379 // Use /Fa and the input filename to determine the asm file name.
2380 StringRef BaseName = llvm::sys::path::filename(BaseInput);
2381 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002382 return C.addResultFile(
2383 MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, JA.getType()),
2384 &JA);
Hans Wennborg2c21f742013-10-17 16:16:23 +00002385 }
2386
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002387 // Output to a temporary file?
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002388 if ((!AtTopLevel && !isSaveTempsEnabled() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002389 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
Chad Rosierbe10f982011-08-02 17:58:04 +00002390 CCGenDiagnostics) {
Chad Rosier97c37372011-08-26 22:27:02 +00002391 StringRef Name = llvm::sys::path::filename(BaseInput);
2392 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002393 std::string TmpName = GetTemporaryPath(
2394 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002395 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002396 }
2397
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002398 SmallString<128> BasePath(BaseInput);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002399 StringRef BaseName;
Daniel Dunbar67fea712011-03-25 18:16:51 +00002400
2401 // Dsymutil actions should use the full path.
Eric Christopher551ef452011-08-23 17:56:55 +00002402 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
Daniel Dunbar67fea712011-03-25 18:16:51 +00002403 BaseName = BasePath;
2404 else
2405 BaseName = llvm::sys::path::filename(BasePath);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002406
2407 // Determine what the derived output name should be.
2408 const char *NamedOutput;
Hans Wennborg2b89a262013-08-06 22:11:28 +00002409
Hans Wennborg8fa96772015-06-13 02:53:50 +00002410 if (JA.getType() == types::TY_Object &&
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00002411 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
2412 // The /Fo or /o flag decides the object filename.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002413 StringRef Val =
2414 C.getArgs()
2415 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
2416 ->getValue();
2417 NamedOutput =
2418 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Object);
Hans Wennborg207fcf02013-08-12 21:56:42 +00002419 } else if (JA.getType() == types::TY_Image &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002420 C.getArgs().hasArg(options::OPT__SLASH_Fe,
2421 options::OPT__SLASH_o)) {
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00002422 // The /Fe or /o flag names the linked file.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002423 StringRef Val =
2424 C.getArgs()
2425 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
2426 ->getValue();
2427 NamedOutput =
2428 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Image);
Hans Wennborgf1a74252013-09-10 20:18:04 +00002429 } else if (JA.getType() == types::TY_Image) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002430 if (IsCLMode()) {
2431 // clang-cl uses BaseName for the executable name.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002432 NamedOutput =
2433 MakeCLOutputFilename(C.getArgs(), "", BaseName, types::TY_Image);
Hans Wennborg207fcf02013-08-12 21:56:42 +00002434 } else if (MultipleArchs && BoundArch) {
Hans Wennborga7707222015-01-09 17:38:53 +00002435 SmallString<128> Output(getDefaultImageName());
Samuel Antaod06239d2016-07-15 23:13:27 +00002436 Output += JA.getOffloadingFileNamePrefix(NormalizedTriple);
Chad Rosier35767232013-04-30 22:01:21 +00002437 Output += "-";
2438 Output.append(BoundArch);
2439 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
Nico Weber2ca4be92016-03-01 23:16:44 +00002440 } else {
Hans Wennborga7707222015-01-09 17:38:53 +00002441 NamedOutput = getDefaultImageName();
Nico Weber2ca4be92016-03-01 23:16:44 +00002442 }
2443 } else if (JA.getType() == types::TY_PCH && IsCLMode()) {
2444 NamedOutput = C.getArgs().MakeArgString(GetClPchPath(C, BaseName).c_str());
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002445 } else {
Hans Wennborg0a096a02013-09-05 17:05:56 +00002446 const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002447 assert(Suffix && "All types used for output should have a suffix.");
2448
2449 std::string::size_type End = std::string::npos;
2450 if (!types::appendSuffixForType(JA.getType()))
2451 End = BaseName.rfind('.');
Chad Rosier35767232013-04-30 22:01:21 +00002452 SmallString<128> Suffixed(BaseName.substr(0, End));
Samuel Antaod06239d2016-07-15 23:13:27 +00002453 Suffixed += JA.getOffloadingFileNamePrefix(NormalizedTriple);
Chad Rosier35767232013-04-30 22:01:21 +00002454 if (MultipleArchs && BoundArch) {
2455 Suffixed += "-";
2456 Suffixed.append(BoundArch);
2457 }
Bob Wilson23a55f12014-12-21 07:00:00 +00002458 // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for
2459 // the unoptimized bitcode so that it does not get overwritten by the ".bc"
2460 // optimized bitcode output.
2461 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) &&
2462 JA.getType() == types::TY_LLVM_BC)
2463 Suffixed += ".tmp";
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002464 Suffixed += '.';
2465 Suffixed += Suffix;
2466 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
2467 }
2468
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002469 // Prepend object file path if -save-temps=obj
2470 if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) &&
2471 JA.getType() != types::TY_PCH) {
2472 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
2473 SmallString<128> TempPath(FinalOutput->getValue());
2474 llvm::sys::path::remove_filename(TempPath);
2475 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
2476 llvm::sys::path::append(TempPath, OutputFileName);
2477 NamedOutput = C.getArgs().MakeArgString(TempPath.c_str());
2478 }
2479
Chad Rosier62135492012-07-09 17:31:28 +00002480 // If we're saving temps and the temp file conflicts with the input file,
Chad Rosier5b58af02012-04-20 20:05:08 +00002481 // then avoid overwriting input file.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002482 if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) {
Chad Rosier5b58af02012-04-20 20:05:08 +00002483 bool SameFile = false;
2484 SmallString<256> Result;
2485 llvm::sys::fs::current_path(Result);
2486 llvm::sys::path::append(Result, BaseName);
2487 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
2488 // Must share the same path to conflict.
2489 if (SameFile) {
2490 StringRef Name = llvm::sys::path::filename(BaseInput);
2491 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002492 std::string TmpName = GetTemporaryPath(
2493 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Chad Rosier5b58af02012-04-20 20:05:08 +00002494 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
2495 }
Chad Rosierf8412cd2011-07-15 21:54:29 +00002496 }
2497
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002498 // As an annoying special case, PCH generation doesn't strip the pathname.
Nico Weber8ab92192016-03-02 23:29:29 +00002499 if (JA.getType() == types::TY_PCH && !IsCLMode()) {
Michael J. Spencere1696752010-12-18 00:19:12 +00002500 llvm::sys::path::remove_filename(BasePath);
2501 if (BasePath.empty())
Daniel Dunbare6c83192009-03-18 09:58:30 +00002502 BasePath = NamedOutput;
2503 else
Michael J. Spencere1696752010-12-18 00:19:12 +00002504 llvm::sys::path::append(BasePath, NamedOutput);
Chad Rosier633dcdc2013-01-24 19:14:47 +00002505 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002506 } else {
Chad Rosier633dcdc2013-01-24 19:14:47 +00002507 return C.addResultFile(NamedOutput, &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002508 }
2509}
2510
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002511std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
Chandler Carruth84559242010-03-22 01:52:07 +00002512 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00002513 // attempting to use this prefix when looking for file paths.
Douglas Katzman26eabf62015-06-24 15:10:30 +00002514 for (const std::string &Dir : PrefixDirs) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00002515 if (Dir.empty())
2516 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00002517 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00002518 llvm::sys::path::append(P, Name);
2519 if (llvm::sys::fs::exists(Twine(P)))
Chandler Carruth84559242010-03-22 01:52:07 +00002520 return P.str();
2521 }
2522
Rafael Espindola609a6642013-06-24 18:33:43 +00002523 SmallString<128> P(ResourceDir);
2524 llvm::sys::path::append(P, Name);
2525 if (llvm::sys::fs::exists(Twine(P)))
Peter Collingbournefa9771f2011-09-06 02:08:31 +00002526 return P.str();
2527
Douglas Katzman26eabf62015-06-24 15:10:30 +00002528 for (const std::string &Dir : TC.getFilePaths()) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00002529 if (Dir.empty())
2530 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00002531 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00002532 llvm::sys::path::append(P, Name);
2533 if (llvm::sys::fs::exists(Twine(P)))
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002534 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002535 }
2536
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002537 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00002538}
2539
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002540void Driver::generatePrefixedToolNames(
2541 const char *Tool, const ToolChain &TC,
2542 SmallVectorImpl<std::string> &Names) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002543 // FIXME: Needs a better variable than DefaultTargetTriple
Chandler Carruth1256cc82016-06-11 04:57:29 +00002544 Names.emplace_back(DefaultTargetTriple + "-" + Tool);
Benjamin Kramer3204b152015-05-29 19:42:19 +00002545 Names.emplace_back(Tool);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00002546
2547 // Allow the discovery of tools prefixed with LLVM's default target triple.
2548 std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
2549 if (LLVMDefaultTargetTriple != DefaultTargetTriple)
2550 Names.emplace_back(LLVMDefaultTargetTriple + "-" + Tool);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002551}
2552
Benjamin Kramer7111b912014-11-04 20:26:01 +00002553static bool ScanDirForExecutable(SmallString<128> &Dir,
2554 ArrayRef<std::string> Names) {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002555 for (const auto &Name : Names) {
2556 llvm::sys::path::append(Dir, Name);
2557 if (llvm::sys::fs::can_execute(Twine(Dir)))
2558 return true;
2559 llvm::sys::path::remove_filename(Dir);
2560 }
2561 return false;
2562}
2563
Simon Atanasyanb16488c2012-10-03 19:52:37 +00002564std::string Driver::GetProgramPath(const char *Name,
2565 const ToolChain &TC) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002566 SmallVector<std::string, 2> TargetSpecificExecutables;
2567 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
2568
Chandler Carruth84559242010-03-22 01:52:07 +00002569 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00002570 // attempting to use this prefix when looking for program paths.
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002571 for (const auto &PrefixDir : PrefixDirs) {
2572 if (llvm::sys::fs::is_directory(PrefixDir)) {
2573 SmallString<128> P(PrefixDir);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002574 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002575 return P.str();
Simon Atanasyana47ba292012-10-31 14:39:28 +00002576 } else {
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002577 SmallString<128> P(PrefixDir + Name);
Rafael Espindola609a6642013-06-24 18:33:43 +00002578 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002579 return P.str();
Simon Atanasyan86bdab72012-10-31 12:01:53 +00002580 }
Chandler Carruth84559242010-03-22 01:52:07 +00002581 }
2582
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002583 const ToolChain::path_list &List = TC.getProgramPaths();
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002584 for (const auto &Path : List) {
2585 SmallString<128> P(Path);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002586 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002587 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002588 }
2589
Daniel Dunbar76ce7412009-03-23 16:15:50 +00002590 // If all else failed, search the path.
Michael J. Spencerb011d482014-11-07 21:30:32 +00002591 for (const auto &TargetSpecificExecutable : TargetSpecificExecutables)
2592 if (llvm::ErrorOr<std::string> P =
2593 llvm::sys::findProgramByName(TargetSpecificExecutable))
Michael J. Spencer04162ea2014-11-04 01:30:55 +00002594 return *P;
Daniel Dunbar6f668772009-03-18 21:34:08 +00002595
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002596 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00002597}
2598
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002599std::string Driver::GetTemporaryPath(StringRef Prefix,
2600 const char *Suffix) const {
Rafael Espindola37d229d2013-06-25 04:26:55 +00002601 SmallString<128> Path;
Rafael Espindolac0809172014-06-12 14:02:15 +00002602 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
Rafael Espindola37d229d2013-06-25 04:26:55 +00002603 if (EC) {
2604 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002605 return "";
2606 }
2607
Rafael Espindola37d229d2013-06-25 04:26:55 +00002608 return Path.str();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002609}
2610
Nico Weber2ca4be92016-03-01 23:16:44 +00002611std::string Driver::GetClPchPath(Compilation &C, StringRef BaseName) const {
2612 SmallString<128> Output;
2613 if (Arg *FpArg = C.getArgs().getLastArg(options::OPT__SLASH_Fp)) {
2614 // FIXME: If anybody needs it, implement this obscure rule:
2615 // "If you specify a directory without a file name, the default file name
2616 // is VCx0.pch., where x is the major version of Visual C++ in use."
2617 Output = FpArg->getValue();
2618
2619 // "If you do not specify an extension as part of the path name, an
2620 // extension of .pch is assumed. "
2621 if (!llvm::sys::path::has_extension(Output))
2622 Output += ".pch";
2623 } else {
2624 Output = BaseName;
2625 llvm::sys::path::replace_extension(Output, ".pch");
2626 }
2627 return Output.str();
2628}
2629
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002630const ToolChain &Driver::getToolChain(const ArgList &Args,
Artem Belevich959e0542015-07-10 19:47:55 +00002631 const llvm::Triple &Target) const {
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002632
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00002633 ToolChain *&TC = ToolChains[Target.str()];
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002634 if (!TC) {
2635 switch (Target.getOS()) {
Reid Kleckner330fb172016-05-11 16:19:05 +00002636 case llvm::Triple::Haiku:
2637 TC = new toolchains::Haiku(*this, Target, Args);
2638 break;
Ed Schouten3c3e58c2015-03-26 11:13:44 +00002639 case llvm::Triple::CloudABI:
2640 TC = new toolchains::CloudABI(*this, Target, Args);
2641 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002642 case llvm::Triple::Darwin:
2643 case llvm::Triple::MacOSX:
2644 case llvm::Triple::IOS:
Tim Northover6f3ff222015-10-30 16:30:27 +00002645 case llvm::Triple::TvOS:
2646 case llvm::Triple::WatchOS:
Rafael Espindola14627962013-11-24 23:28:23 +00002647 TC = new toolchains::DarwinClang(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002648 break;
2649 case llvm::Triple::DragonFly:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002650 TC = new toolchains::DragonFly(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002651 break;
2652 case llvm::Triple::OpenBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002653 TC = new toolchains::OpenBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002654 break;
Eli Friedman9fa28852012-08-08 23:57:20 +00002655 case llvm::Triple::Bitrig:
2656 TC = new toolchains::Bitrig(*this, Target, Args);
2657 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002658 case llvm::Triple::NetBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002659 TC = new toolchains::NetBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002660 break;
2661 case llvm::Triple::FreeBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002662 TC = new toolchains::FreeBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002663 break;
2664 case llvm::Triple::Minix:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002665 TC = new toolchains::Minix(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002666 break;
2667 case llvm::Triple::Linux:
Andrey Turetskiy4798eb62016-06-16 10:36:09 +00002668 case llvm::Triple::ELFIAMCU:
Chandler Carruthcf705b22012-01-25 21:03:58 +00002669 if (Target.getArch() == llvm::Triple::hexagon)
Douglas Katzman54366072015-07-27 16:53:08 +00002670 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00002671 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
2672 !Target.hasEnvironment())
2673 TC = new toolchains::MipsLLVMToolChain(*this, Target, Args);
Chandler Carruthcf705b22012-01-25 21:03:58 +00002674 else
Rafael Espindola1af7c212012-02-19 01:38:32 +00002675 TC = new toolchains::Linux(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002676 break;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002677 case llvm::Triple::NaCl:
Douglas Katzman54366072015-07-27 16:53:08 +00002678 TC = new toolchains::NaClToolChain(*this, Target, Args);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002679 break;
David Chisnallf571cde2012-02-15 13:39:01 +00002680 case llvm::Triple::Solaris:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002681 TC = new toolchains::Solaris(*this, Target, Args);
David Chisnallf571cde2012-02-15 13:39:01 +00002682 break;
Tom Stellard8fa33092015-07-18 01:49:05 +00002683 case llvm::Triple::AMDHSA:
2684 TC = new toolchains::AMDGPUToolChain(*this, Target, Args);
2685 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002686 case llvm::Triple::Win32:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002687 switch (Target.getEnvironment()) {
2688 default:
2689 if (Target.isOSBinFormatELF())
2690 TC = new toolchains::Generic_ELF(*this, Target, Args);
2691 else if (Target.isOSBinFormatMachO())
2692 TC = new toolchains::MachO(*this, Target, Args);
2693 else
2694 TC = new toolchains::Generic_GCC(*this, Target, Args);
2695 break;
2696 case llvm::Triple::GNU:
Yaron Keren1c0070c2015-07-02 04:45:27 +00002697 TC = new toolchains::MinGW(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002698 break;
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002699 case llvm::Triple::Itanium:
2700 TC = new toolchains::CrossWindowsToolChain(*this, Target, Args);
2701 break;
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002702 case llvm::Triple::MSVC:
2703 case llvm::Triple::UnknownEnvironment:
Saleem Abdulrasool819f3912014-10-22 02:37:29 +00002704 TC = new toolchains::MSVCToolChain(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002705 break;
2706 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002707 break;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002708 case llvm::Triple::CUDA:
2709 TC = new toolchains::CudaToolChain(*this, Target, Args);
2710 break;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00002711 case llvm::Triple::PS4:
2712 TC = new toolchains::PS4CPU(*this, Target, Args);
2713 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002714 default:
Douglas Katzman9f5e70e2015-05-26 18:01:33 +00002715 // Of these targets, Hexagon is the only one that might have
2716 // an OS of Linux, in which case it got handled above already.
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002717 switch (Target.getArch()) {
2718 case llvm::Triple::tce:
Rafael Espindola84b588b2013-03-18 18:10:27 +00002719 TC = new toolchains::TCEToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002720 break;
2721 case llvm::Triple::hexagon:
Douglas Katzman54366072015-07-27 16:53:08 +00002722 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002723 break;
Jacques Pienaard964cc22016-03-28 21:02:54 +00002724 case llvm::Triple::lanai:
2725 TC = new toolchains::LanaiToolChain(*this, Target, Args);
2726 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002727 case llvm::Triple::xcore:
Douglas Katzman54366072015-07-27 16:53:08 +00002728 TC = new toolchains::XCoreToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002729 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00002730 case llvm::Triple::wasm32:
2731 case llvm::Triple::wasm64:
2732 TC = new toolchains::WebAssembly(*this, Target, Args);
2733 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002734 default:
Douglas Katzmand6e597c2015-09-17 19:56:40 +00002735 if (Target.getVendor() == llvm::Triple::Myriad)
2736 TC = new toolchains::MyriadToolChain(*this, Target, Args);
2737 else if (Target.isOSBinFormatELF())
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002738 TC = new toolchains::Generic_ELF(*this, Target, Args);
2739 else if (Target.isOSBinFormatMachO())
2740 TC = new toolchains::MachO(*this, Target, Args);
2741 else
2742 TC = new toolchains::Generic_GCC(*this, Target, Args);
2743 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002744 }
2745 }
2746 return *TC;
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00002747}
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00002748
Rafael Espindola2f69d402013-03-18 15:33:26 +00002749bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
Douglas Katzman00249092015-06-12 15:45:21 +00002750 // Say "no" if there is not exactly one input of a type clang understands.
Nico Weber5a459f82016-02-23 19:30:43 +00002751 if (JA.size() != 1 ||
2752 !types::isAcceptedByClang((*JA.input_begin())->getType()))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002753 return false;
2754
Douglas Katzman00249092015-06-12 15:45:21 +00002755 // And say "no" if this is not a kind of action clang understands.
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002756 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
Bob Wilson23a55f12014-12-21 07:00:00 +00002757 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002758 return false;
2759
2760 return true;
2761}
2762
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002763/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
2764/// grouped values as integers. Numbers which are not provided are set to 0.
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002765///
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002766/// \return True if the entire string was parsed (9.2), or all groups were
2767/// parsed (10.3.5extrastuff).
2768bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002769 unsigned &Minor, unsigned &Micro,
2770 bool &HadExtra) {
2771 HadExtra = false;
2772
2773 Major = Minor = Micro = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002774 if (*Str == '\0')
Bob Wilson433cb312015-04-07 01:03:35 +00002775 return false;
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002776
2777 char *End;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002778 Major = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002779 if (*Str != '\0' && *End == '\0')
2780 return true;
2781 if (*End != '.')
2782 return false;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002783
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002784 Str = End + 1;
2785 Minor = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002786 if (*Str != '\0' && *End == '\0')
2787 return true;
2788 if (*End != '.')
2789 return false;
2790
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002791 Str = End + 1;
2792 Micro = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002793 if (*Str != '\0' && *End == '\0')
2794 return true;
2795 if (Str == End)
2796 return false;
2797 HadExtra = true;
2798 return true;
2799}
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002800
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00002801/// Parse digits from a string \p Str and fulfill \p Digits with
2802/// the parsed numbers. This method assumes that the max number of
2803/// digits to look for is equal to Digits.size().
2804///
2805/// \return True if the entire string was parsed and there are
2806/// no extra characters remaining at the end.
2807bool Driver::GetReleaseVersion(const char *Str,
2808 MutableArrayRef<unsigned> Digits) {
2809 if (*Str == '\0')
2810 return false;
2811
2812 char *End;
2813 unsigned CurDigit = 0;
2814 while (CurDigit < Digits.size()) {
2815 unsigned Digit = (unsigned)strtol(Str, &End, 10);
2816 Digits[CurDigit] = Digit;
2817 if (*Str != '\0' && *End == '\0')
2818 return true;
2819 if (*End != '.' || Str == End)
2820 return false;
2821 Str = End + 1;
2822 CurDigit++;
2823 }
2824
2825 // More digits than requested, bail out...
2826 return false;
2827}
2828
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002829std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
2830 unsigned IncludedFlagsBitmask = 0;
Rafael Espindolacc707bc2013-09-25 15:54:41 +00002831 unsigned ExcludedFlagsBitmask = options::NoDriverOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002832
2833 if (Mode == CLMode) {
Hans Wennborg19076102013-07-31 20:51:53 +00002834 // Include CL and Core options.
2835 IncludedFlagsBitmask |= options::CLOption;
2836 IncludedFlagsBitmask |= options::CoreOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002837 } else {
2838 ExcludedFlagsBitmask |= options::CLOption;
2839 }
2840
2841 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
2842}
Benjamin Kramerab88f622014-03-25 18:02:07 +00002843
Douglas Katzmanf08fadf2015-06-04 14:40:44 +00002844bool clang::driver::isOptimizationLevelFast(const ArgList &Args) {
Benjamin Kramerab88f622014-03-25 18:02:07 +00002845 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false);
2846}