blob: b2cd4f75a1197c4025fcc8f5c0110ef55c436511 [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
Richard Smithdd4ad3d2016-08-30 19:06:26 +0000180 // --precompile only runs up to precompilation.
181 } else if ((PhaseArg = DAL.getLastArg(options::OPT__precompile))) {
182 FinalPhase = phases::Precompile;
183
Bob Wilson23a55f12014-12-21 07:00:00 +0000184 // -{fsyntax-only,-analyze,emit-ast} only run up to the compiler.
Chad Rosier7742b5d2011-07-27 23:36:45 +0000185 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +0000186 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
Ben Langmuir2cb4a782014-02-05 22:21:15 +0000187 (PhaseArg = DAL.getLastArg(options::OPT_verify_pch)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000188 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
Fariborz Jahanian73223bb2012-04-02 15:59:19 +0000189 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
Ted Kremenekf7639e12012-03-06 20:06:33 +0000190 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000191 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
Chad Rosier1aeb15a2012-03-06 23:14:35 +0000192 options::OPT__analyze_auto)) ||
Bob Wilson23a55f12014-12-21 07:00:00 +0000193 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast))) {
Chad Rosier7742b5d2011-07-27 23:36:45 +0000194 FinalPhase = phases::Compile;
195
Bob Wilson23a55f12014-12-21 07:00:00 +0000196 // -S only runs up to the backend.
197 } else if ((PhaseArg = DAL.getLastArg(options::OPT_S))) {
198 FinalPhase = phases::Backend;
199
Artem Belevich4242f412015-07-28 21:01:21 +0000200 // -c compilation only runs up to the assembler.
201 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
Chad Rosier7742b5d2011-07-27 23:36:45 +0000202 FinalPhase = phases::Assemble;
203
204 // Otherwise do everything.
205 } else
206 FinalPhase = phases::Link;
207
208 if (FinalPhaseArg)
209 *FinalPhaseArg = PhaseArg;
210
211 return FinalPhase;
212}
213
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000214static Arg *MakeInputArg(DerivedArgList &Args, OptTable *Opts,
Hans Wennborged1d0722013-08-13 21:32:29 +0000215 StringRef Value) {
216 Arg *A = new Arg(Opts->getOption(options::OPT_INPUT), Value,
217 Args.getBaseArgs().MakeIndex(Value), Value.data());
Hans Wennborg55362852014-05-02 22:55:30 +0000218 Args.AddSynthesizedArg(A);
Hans Wennborged1d0722013-08-13 21:32:29 +0000219 A->claim();
220 return A;
221}
222
Daniel Dunbar775d4062010-06-11 22:00:26 +0000223DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
224 DerivedArgList *DAL = new DerivedArgList(Args);
225
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000226 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
Nirav Daveb0bb6142015-11-24 16:07:21 +0000227 bool HasNodefaultlib = Args.hasArg(options::OPT_nodefaultlibs);
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000228 for (Arg *A : Args) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000229 // Unfortunately, we have to parse some forwarding options (-Xassembler,
230 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
231 // (assembler and preprocessor), or bypass a previous driver ('collect2').
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000232
233 // Rewrite linker options, to replace --no-demangle with a custom internal
234 // option.
235 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
236 A->getOption().matches(options::OPT_Xlinker)) &&
237 A->containsValue("--no-demangle")) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000238 // Add the rewritten no-demangle argument.
239 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
240
241 // Add the remaining values as Xlinker arguments.
Benjamin Kramer72e64312015-09-24 14:48:49 +0000242 for (StringRef Val : A->getValues())
Douglas Katzmana34b7bf2015-06-30 19:32:57 +0000243 if (Val != "--no-demangle")
244 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker), Val);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000245
246 continue;
247 }
248
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000249 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
250 // some build systems. We don't try to be complete here because we don't
251 // care to encourage this usage model.
252 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
Richard Smithbd55daf2012-11-01 04:30:05 +0000253 (A->getValue(0) == StringRef("-MD") ||
254 A->getValue(0) == StringRef("-MMD"))) {
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000255 // Rewrite to -MD/-MMD along with -MF.
Richard Smithbd55daf2012-11-01 04:30:05 +0000256 if (A->getValue(0) == StringRef("-MD"))
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000257 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
258 else
259 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
Michael J. Spencer70d85be2012-11-07 23:37:14 +0000260 if (A->getNumValues() == 2)
261 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
262 A->getValue(1));
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000263 continue;
264 }
265
Shantonu Senafeb03b2010-09-17 18:39:08 +0000266 // Rewrite reserved library names.
267 if (A->getOption().matches(options::OPT_l)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000268 StringRef Value = A->getValue();
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000269
Shantonu Senafeb03b2010-09-17 18:39:08 +0000270 // Rewrite unless -nostdlib is present.
Nirav Daveb0bb6142015-11-24 16:07:21 +0000271 if (!HasNostdlib && !HasNodefaultlib && Value == "stdc++") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000272 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_stdcxx));
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000273 continue;
274 }
Shantonu Senafeb03b2010-09-17 18:39:08 +0000275
276 // Rewrite unconditionally.
277 if (Value == "cc_kext") {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000278 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_reserved_lib_cckext));
Shantonu Senafeb03b2010-09-17 18:39:08 +0000279 continue;
280 }
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000281 }
282
Hans Wennborged1d0722013-08-13 21:32:29 +0000283 // Pick up inputs via the -- option.
284 if (A->getOption().matches(options::OPT__DASH_DASH)) {
285 A->claim();
Benjamin Kramer72e64312015-09-24 14:48:49 +0000286 for (StringRef Val : A->getValues())
Douglas Katzmana34b7bf2015-06-30 19:32:57 +0000287 DAL->append(MakeInputArg(*DAL, Opts, Val));
Hans Wennborged1d0722013-08-13 21:32:29 +0000288 continue;
289 }
290
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000291 DAL->append(A);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000292 }
Daniel Dunbar775d4062010-06-11 22:00:26 +0000293
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000294 // Enforce -static if -miamcu is present.
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000295 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false))
296 DAL->AddFlagArg(0, Opts->getOption(options::OPT_static));
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000297
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000298// Add a default value of -mlinker-version=, if one was given and the user
299// didn't specify one.
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000300#if defined(HOST_LINK_VERSION)
Tim Northover018578c2015-06-12 19:21:35 +0000301 if (!Args.hasArg(options::OPT_mlinker_version_EQ) &&
302 strlen(HOST_LINK_VERSION) > 0) {
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000303 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
304 HOST_LINK_VERSION);
Daniel Dunbarb613ffc2010-08-17 22:32:45 +0000305 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000306 }
307#endif
308
Daniel Dunbar775d4062010-06-11 22:00:26 +0000309 return DAL;
310}
311
Artem Belevich959e0542015-07-10 19:47:55 +0000312/// \brief Compute target triple from args.
313///
314/// This routine provides the logic to compute a target triple from various
315/// args passed to the driver and the default triple string.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000316static llvm::Triple computeTargetTriple(const Driver &D,
317 StringRef DefaultTargetTriple,
Artem Belevich959e0542015-07-10 19:47:55 +0000318 const ArgList &Args,
319 StringRef DarwinArchName = "") {
320 // FIXME: Already done in Compilation *Driver::BuildCompilation
321 if (const Arg *A = Args.getLastArg(options::OPT_target))
322 DefaultTargetTriple = A->getValue();
323
324 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
325
326 // Handle Apple-specific options available here.
327 if (Target.isOSBinFormatMachO()) {
328 // If an explict Darwin arch name is given, that trumps all.
329 if (!DarwinArchName.empty()) {
330 tools::darwin::setTripleTypeForMachOArchName(Target, DarwinArchName);
331 return Target;
332 }
333
334 // Handle the Darwin '-arch' flag.
335 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
336 StringRef ArchName = A->getValue();
337 tools::darwin::setTripleTypeForMachOArchName(Target, ArchName);
338 }
339 }
340
341 // Handle pseudo-target flags '-mlittle-endian'/'-EL' and
342 // '-mbig-endian'/'-EB'.
343 if (Arg *A = Args.getLastArg(options::OPT_mlittle_endian,
344 options::OPT_mbig_endian)) {
345 if (A->getOption().matches(options::OPT_mlittle_endian)) {
346 llvm::Triple LE = Target.getLittleEndianArchVariant();
347 if (LE.getArch() != llvm::Triple::UnknownArch)
348 Target = std::move(LE);
349 } else {
350 llvm::Triple BE = Target.getBigEndianArchVariant();
351 if (BE.getArch() != llvm::Triple::UnknownArch)
352 Target = std::move(BE);
353 }
354 }
355
356 // Skip further flag support on OSes which don't support '-m32' or '-m64'.
Douglas Katzman15a63ed2015-08-12 18:36:12 +0000357 if (Target.getArch() == llvm::Triple::tce ||
358 Target.getOS() == llvm::Triple::Minix)
Artem Belevich959e0542015-07-10 19:47:55 +0000359 return Target;
360
361 // Handle pseudo-target flags '-m64', '-mx32', '-m32' and '-m16'.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000362 Arg *A = Args.getLastArg(options::OPT_m64, options::OPT_mx32,
363 options::OPT_m32, options::OPT_m16);
364 if (A) {
Artem Belevich959e0542015-07-10 19:47:55 +0000365 llvm::Triple::ArchType AT = llvm::Triple::UnknownArch;
366
367 if (A->getOption().matches(options::OPT_m64)) {
368 AT = Target.get64BitArchVariant().getArch();
369 if (Target.getEnvironment() == llvm::Triple::GNUX32)
370 Target.setEnvironment(llvm::Triple::GNU);
371 } else if (A->getOption().matches(options::OPT_mx32) &&
372 Target.get64BitArchVariant().getArch() == llvm::Triple::x86_64) {
373 AT = llvm::Triple::x86_64;
374 Target.setEnvironment(llvm::Triple::GNUX32);
375 } else if (A->getOption().matches(options::OPT_m32)) {
376 AT = Target.get32BitArchVariant().getArch();
377 if (Target.getEnvironment() == llvm::Triple::GNUX32)
378 Target.setEnvironment(llvm::Triple::GNU);
379 } else if (A->getOption().matches(options::OPT_m16) &&
380 Target.get32BitArchVariant().getArch() == llvm::Triple::x86) {
381 AT = llvm::Triple::x86;
382 Target.setEnvironment(llvm::Triple::CODE16);
383 }
384
385 if (AT != llvm::Triple::UnknownArch && AT != Target.getArch())
386 Target.setArch(AT);
387 }
388
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000389 // Handle -miamcu flag.
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000390 if (Args.hasFlag(options::OPT_miamcu, options::OPT_mno_iamcu, false)) {
391 if (Target.get32BitArchVariant().getArch() != llvm::Triple::x86)
392 D.Diag(diag::err_drv_unsupported_opt_for_target) << "-miamcu"
393 << Target.str();
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000394
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000395 if (A && !A->getOption().matches(options::OPT_m32))
396 D.Diag(diag::err_drv_argument_not_allowed_with)
397 << "-miamcu" << A->getBaseArg().getAsString(Args);
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000398
Andrey Turetskiy5fea71c2016-06-29 10:57:17 +0000399 Target.setArch(llvm::Triple::x86);
400 Target.setArchName("i586");
401 Target.setEnvironment(llvm::Triple::UnknownEnvironment);
402 Target.setEnvironmentName("");
403 Target.setOS(llvm::Triple::ELFIAMCU);
404 Target.setVendor(llvm::Triple::UnknownVendor);
405 Target.setVendorName("intel");
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000406 }
407
Artem Belevich959e0542015-07-10 19:47:55 +0000408 return Target;
409}
410
Teresa Johnson945bc502015-10-15 20:35:53 +0000411// \brief Parse the LTO options and record the type of LTO compilation
412// based on which -f(no-)?lto(=.*)? option occurs last.
413void Driver::setLTOMode(const llvm::opt::ArgList &Args) {
414 LTOMode = LTOK_None;
415 if (!Args.hasFlag(options::OPT_flto, options::OPT_flto_EQ,
416 options::OPT_fno_lto, false))
417 return;
418
419 StringRef LTOName("full");
420
421 const Arg *A = Args.getLastArg(options::OPT_flto_EQ);
Teresa Johnson6ef80dc2015-11-02 18:03:12 +0000422 if (A)
423 LTOName = A->getValue();
Teresa Johnson945bc502015-10-15 20:35:53 +0000424
425 LTOMode = llvm::StringSwitch<LTOKind>(LTOName)
426 .Case("full", LTOK_Full)
427 .Case("thin", LTOK_Thin)
428 .Default(LTOK_Unknown);
429
430 if (LTOMode == LTOK_Unknown) {
431 assert(A);
432 Diag(diag::err_drv_unsupported_option_argument) << A->getOption().getName()
433 << A->getValue();
434 }
435}
436
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000437void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
438 InputList &Inputs) {
439
440 //
441 // CUDA
442 //
443 // We need to generate a CUDA toolchain if any of the inputs has a CUDA type.
444 if (llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
445 return types::isCuda(I.first);
446 })) {
447 const ToolChain &TC = getToolChain(
448 C.getInputArgs(),
Samuel Antaod06239d2016-07-15 23:13:27 +0000449 llvm::Triple(C.getSingleOffloadToolChain<Action::OFK_Host>()
450 ->getTriple()
451 .isArch64Bit()
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000452 ? "nvptx64-nvidia-cuda"
453 : "nvptx-nvidia-cuda"));
454 C.addOffloadDeviceToolChain(&TC, Action::OFK_Cuda);
455 }
456
457 //
458 // TODO: Add support for other offloading programming models here.
459 //
460
461 return;
462}
463
Chris Lattner54b16772011-07-23 17:14:25 +0000464Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000465 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
466
Eric Christopherf901e852011-08-17 22:59:59 +0000467 // FIXME: Handle environment options which affect driver behavior, somewhere
Bill Wendlingadbeb9f2012-03-12 21:24:57 +0000468 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
Chad Rosier82301162011-09-14 00:47:55 +0000469
David Majnemer85c25b42016-07-24 17:44:03 +0000470 if (Optional<std::string> CompilerPathValue =
471 llvm::sys::Process::GetEnv("COMPILER_PATH")) {
472 StringRef CompilerPath = *CompilerPathValue;
Chad Rosier82301162011-09-14 00:47:55 +0000473 while (!CompilerPath.empty()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000474 std::pair<StringRef, StringRef> Split =
475 CompilerPath.split(llvm::sys::EnvPathSeparator);
Chad Rosier82301162011-09-14 00:47:55 +0000476 PrefixDirs.push_back(Split.first);
477 CompilerPath = Split.second;
478 }
479 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000480
Hans Wennborg70850d82013-07-18 20:29:38 +0000481 // We look for the driver mode option early, because the mode can affect
482 // how other options are parsed.
Zachary Turneraff19c32016-08-12 17:47:52 +0000483 ParseDriverMode(ClangExecutable, ArgList.slice(1));
Hans Wennborg70850d82013-07-18 20:29:38 +0000484
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000485 // FIXME: What are we going to do with -V and -b?
486
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000487 // FIXME: This stuff needs to go into the Compilation, not the driver.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000488 bool CCCPrintPhases;
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000489
David Blaikie69a1d8c2015-06-22 22:07:27 +0000490 InputArgList Args = ParseArgStrings(ArgList.slice(1));
Daniel Dunbaracd69572009-12-04 21:55:23 +0000491
Filipe Cabecinhas136f35e2015-07-18 06:35:24 +0000492 // Silence driver warnings if requested
493 Diags.setIgnoreAllWarnings(Args.hasArg(options::OPT_w));
494
Rafael Espindola59ae7992009-12-07 18:28:29 +0000495 // -no-canonical-prefixes is used very early in main.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000496 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
Rafael Espindola59ae7992009-12-07 18:28:29 +0000497
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000498 // Ignore -pipe.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000499 Args.ClaimAllArgs(options::OPT_pipe);
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000500
Daniel Dunbaracd69572009-12-04 21:55:23 +0000501 // Extract -ccc args.
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000502 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000503 // FIXME: We need to figure out where this behavior should live. Most of it
504 // should be outside in the client; the parts that aren't should have proper
505 // options, either by introducing new ones or by overloading gcc ones like -V
506 // or -b.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000507 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
David Blaikie69a1d8c2015-06-22 22:07:27 +0000508 CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings);
509 if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
Richard Smithbd55daf2012-11-01 04:30:05 +0000510 CCCGenericGCCName = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000511 CCCUsePCH =
512 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
Joerg Sonnenberger17d75512012-02-22 19:15:16 +0000513 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
514 // and getToolChain is const.
Hans Wennborg2e274592013-08-13 23:38:57 +0000515 if (IsCLMode()) {
Hans Wennborg73609a02014-03-28 01:19:04 +0000516 // clang-cl targets MSVC-style Win32.
Hans Wennborg2e274592013-08-13 23:38:57 +0000517 llvm::Triple T(DefaultTargetTriple);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000518 T.setOS(llvm::Triple::Win32);
Hans Wennborg0f0e8d62015-09-18 17:11:50 +0000519 T.setVendor(llvm::Triple::PC);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000520 T.setEnvironment(llvm::Triple::MSVC);
Hans Wennborg2e274592013-08-13 23:38:57 +0000521 DefaultTargetTriple = T.str();
522 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000523 if (const Arg *A = Args.getLastArg(options::OPT_target))
Richard Smithbd55daf2012-11-01 04:30:05 +0000524 DefaultTargetTriple = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000525 if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
Richard Smithbd55daf2012-11-01 04:30:05 +0000526 Dir = InstalledDir = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000527 for (const Arg *A : Args.filtered(options::OPT_B)) {
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000528 A->claim();
Richard Smithbd55daf2012-11-01 04:30:05 +0000529 PrefixDirs.push_back(A->getValue(0));
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000530 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000531 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000532 SysRoot = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000533 if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +0000534 DyldPrefix = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000535 if (Args.hasArg(options::OPT_nostdlib))
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +0000536 UseStdLib = false;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000537
David Blaikie69a1d8c2015-06-22 22:07:27 +0000538 if (const Arg *A = Args.getLastArg(options::OPT_resource_dir))
Bob Wilsona20a1da2013-03-23 05:17:59 +0000539 ResourceDir = A->getValue();
Jim Grosbach061dabf2013-03-12 20:17:58 +0000540
David Blaikie69a1d8c2015-06-22 22:07:27 +0000541 if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000542 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
543 .Case("cwd", SaveTempsCwd)
544 .Case("obj", SaveTempsObj)
545 .Default(SaveTempsCwd);
546 }
547
Steven Wu1257cd82016-05-18 17:04:52 +0000548 setLTOMode(Args);
549
Steven Wu574b0f22016-03-01 01:07:58 +0000550 // Ignore -fembed-bitcode options with LTO
551 // since the output will be bitcode anyway.
Steven Wu1257cd82016-05-18 17:04:52 +0000552 if (getLTOMode() == LTOK_None) {
Steven Wu27fb5222016-05-11 16:26:03 +0000553 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
554 StringRef Name = A->getValue();
555 unsigned Model = llvm::StringSwitch<unsigned>(Name)
556 .Case("off", EmbedNone)
557 .Case("all", EmbedBitcode)
558 .Case("bitcode", EmbedBitcode)
559 .Case("marker", EmbedMarker)
560 .Default(~0U);
561 if (Model == ~0U) {
562 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
563 << Name;
564 } else
565 BitcodeEmbed = static_cast<BitcodeEmbedMode>(Model);
566 }
Steven Wu574b0f22016-03-01 01:07:58 +0000567 } else {
568 // claim the bitcode option under LTO so no warning is issued.
Steven Wu27fb5222016-05-11 16:26:03 +0000569 Args.ClaimAllArgs(options::OPT_fembed_bitcode_EQ);
Steven Wu574b0f22016-03-01 01:07:58 +0000570 }
571
David Blaikie69a1d8c2015-06-22 22:07:27 +0000572 std::unique_ptr<llvm::opt::InputArgList> UArgs =
573 llvm::make_unique<InputArgList>(std::move(Args));
574
Daniel Dunbar775d4062010-06-11 22:00:26 +0000575 // Perform the default argument translations.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000576 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
Daniel Dunbar775d4062010-06-11 22:00:26 +0000577
Chandler Carruthcb916192012-01-25 08:49:21 +0000578 // Owned by the host.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000579 const ToolChain &TC = getToolChain(
580 *UArgs, computeTargetTriple(*this, DefaultTargetTriple, *UArgs));
Chandler Carruthcb916192012-01-25 08:49:21 +0000581
Daniel Dunbar3ce436d2009-03-16 06:42:30 +0000582 // The compilation takes ownership of Args.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000583 Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000584
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000585 if (!HandleImmediateArgs(*C))
586 return C;
587
Chad Rosierecdede82011-08-12 22:08:57 +0000588 // Construct the list of inputs.
589 InputList Inputs;
Hans Wennborged1d0722013-08-13 21:32:29 +0000590 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
Chad Rosierecdede82011-08-12 22:08:57 +0000591
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000592 // Populate the tool chains for the offloading devices, if any.
593 CreateOffloadingDeviceToolChains(*C, Inputs);
Justin Lebar0e450a52016-03-30 23:30:25 +0000594
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000595 // Construct the list of abstract actions to perform for this compilation. On
Tim Northover157d9112014-01-16 08:48:16 +0000596 // MachO targets this uses the driver-driver and universal actions.
597 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000598 BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000599 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000600 BuildActions(*C, C->getArgs(), Inputs, C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000601
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000602 if (CCCPrintPhases) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000603 PrintActions(*C);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000604 return C;
605 }
606
607 BuildJobs(*C);
Daniel Dunbaradc91e62009-03-15 01:38:15 +0000608
609 return C;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000610}
611
Justin Bognered9cbe02015-07-09 06:58:31 +0000612static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args) {
613 llvm::opt::ArgStringList ASL;
614 for (const auto *A : Args)
615 A->render(Args, ASL);
616
617 for (auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
618 if (I != ASL.begin())
619 OS << ' ';
620 Command::printArg(OS, *I, true);
621 }
622 OS << '\n';
623}
624
Eric Christopherf901e852011-08-17 22:59:59 +0000625// When clang crashes, produce diagnostic information including the fully
626// preprocessed source file(s). Request that the developer attach the
Chad Rosierbe10f982011-08-02 17:58:04 +0000627// diagnostic information to a bug report.
628void Driver::generateCompilationDiagnostics(Compilation &C,
Justin Bognere1a33d12014-10-20 21:02:05 +0000629 const Command &FailingCommand) {
Chad Rosier877c0a22012-02-22 00:30:39 +0000630 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
Chad Rosier62135492012-07-09 17:31:28 +0000631 return;
Chad Rosierbee5a1d2012-03-07 00:30:40 +0000632
Chad Rosierdbf46a12013-02-01 18:30:26 +0000633 // Don't try to generate diagnostics for link or dsymutil jobs.
Justin Bognere1a33d12014-10-20 21:02:05 +0000634 if (FailingCommand.getCreator().isLinkJob() ||
635 FailingCommand.getCreator().isDsymutilJob())
Chad Rosier877c0a22012-02-22 00:30:39 +0000636 return;
637
Chad Rosier8179f112012-06-19 17:51:34 +0000638 // Print the version of the compiler.
639 PrintVersion(C, llvm::errs());
640
Chad Rosierbe10f982011-08-02 17:58:04 +0000641 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000642 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
643 "crash backtrace, preprocessed source, and associated run script.";
Chad Rosierbe10f982011-08-02 17:58:04 +0000644
645 // Suppress driver output and emit preprocessor output to temp file.
Hans Wennborg70850d82013-07-18 20:29:38 +0000646 Mode = CPPMode;
Chad Rosierbe10f982011-08-02 17:58:04 +0000647 CCGenDiagnostics = true;
648
Chad Rosiercdb008d2011-11-02 21:29:05 +0000649 // Save the original job command(s).
Justin Bogner25645152014-10-21 17:24:44 +0000650 Command Cmd = FailingCommand;
Chad Rosiercdb008d2011-11-02 21:29:05 +0000651
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000652 // Keep track of whether we produce any errors while trying to produce
653 // preprocessed sources.
654 DiagnosticErrorTrap Trap(Diags);
655
656 // Suppress tool output.
Chad Rosierbe10f982011-08-02 17:58:04 +0000657 C.initCompilationForDiagnostics();
Chad Rosierecdede82011-08-12 22:08:57 +0000658
659 // Construct the list of inputs.
660 InputList Inputs;
661 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000662
Chad Rosier4f81fc22011-08-12 23:30:05 +0000663 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000664 bool IgnoreInput = false;
665
666 // Ignore input from stdin or any inputs that cannot be preprocessed.
Paul Robinsonf44157d2014-04-28 22:24:44 +0000667 // Check type first as not all linker inputs have a value.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000668 if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
Paul Robinsonf44157d2014-04-28 22:24:44 +0000669 IgnoreInput = true;
670 } else if (!strcmp(it->second->getValue(), "-")) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000671 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000672 << "Error generating preprocessed source(s) - "
673 "ignoring input from stdin.";
Chad Rosierd57133d2011-08-18 00:22:25 +0000674 IgnoreInput = true;
Chad Rosierd57133d2011-08-18 00:22:25 +0000675 }
676
677 if (IgnoreInput) {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000678 it = Inputs.erase(it);
679 ie = Inputs.end();
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000680 } else {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000681 ++it;
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000682 }
Chad Rosier4f81fc22011-08-12 23:30:05 +0000683 }
Chad Rosierd57133d2011-08-18 00:22:25 +0000684
Chad Rosierc5103c32013-01-29 23:57:10 +0000685 if (Inputs.empty()) {
686 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000687 << "Error generating preprocessed source(s) - "
688 "no preprocessable inputs.";
Chad Rosierc5103c32013-01-29 23:57:10 +0000689 return;
690 }
691
Chad Rosiere75ef402011-09-06 23:52:36 +0000692 // Don't attempt to generate preprocessed files if multiple -arch options are
Chad Rosier636d2832012-02-13 18:16:28 +0000693 // used, unless they're all duplicates.
694 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000695 for (const Arg *A : C.getArgs()) {
Chad Rosiere75ef402011-09-06 23:52:36 +0000696 if (A->getOption().matches(options::OPT_arch)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000697 StringRef ArchName = A->getValue();
Chad Rosier636d2832012-02-13 18:16:28 +0000698 ArchNames.insert(ArchName);
Chad Rosiere75ef402011-09-06 23:52:36 +0000699 }
700 }
Chad Rosier636d2832012-02-13 18:16:28 +0000701 if (ArchNames.size() > 1) {
702 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000703 << "Error generating preprocessed source(s) - cannot generate "
704 "preprocessed source with multiple -arch options.";
Chad Rosier636d2832012-02-13 18:16:28 +0000705 return;
706 }
Chad Rosiere75ef402011-09-06 23:52:36 +0000707
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000708 // Construct the list of abstract actions to perform for this compilation. On
709 // Darwin OSes this uses the driver-driver and builds universal actions.
Chandler Carruthcb916192012-01-25 08:49:21 +0000710 const ToolChain &TC = C.getDefaultToolChain();
Tim Northover157d9112014-01-16 08:48:16 +0000711 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000712 BuildUniversalActions(C, TC, Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000713 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000714 BuildActions(C, C.getArgs(), Inputs, C.getActions());
Chad Rosierbe10f982011-08-02 17:58:04 +0000715
716 BuildJobs(C);
717
718 // If there were errors building the compilation, quit now.
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000719 if (Trap.hasErrorOccurred()) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000720 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000721 << "Error generating preprocessed source(s).";
Chad Rosierbe10f982011-08-02 17:58:04 +0000722 return;
723 }
724
725 // Generate preprocessed output.
Chad Rosierdd60e092013-01-29 20:15:05 +0000726 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
Justin Bogner0cd92482015-07-02 22:52:08 +0000727 C.ExecuteJobs(C.getJobs(), FailingCommands);
Chad Rosierbe10f982011-08-02 17:58:04 +0000728
Justin Bognerbc89b182014-10-20 21:20:27 +0000729 // If any of the preprocessing commands failed, clean up and exit.
730 if (!FailingCommands.empty()) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000731 if (!isSaveTempsEnabled())
Chad Rosierbe10f982011-08-02 17:58:04 +0000732 C.CleanupFileList(C.getTempFiles(), true);
733
734 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000735 << "Error generating preprocessed source(s).";
Justin Bognerbc89b182014-10-20 21:20:27 +0000736 return;
Chad Rosierbe10f982011-08-02 17:58:04 +0000737 }
Justin Bognerbc89b182014-10-20 21:20:27 +0000738
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000739 const ArgStringList &TempFiles = C.getTempFiles();
740 if (TempFiles.empty()) {
741 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000742 << "Error generating preprocessed source(s).";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000743 return;
744 }
745
Justin Bognerbc89b182014-10-20 21:20:27 +0000746 Diag(clang::diag::note_drv_command_failed_diag_msg)
747 << "\n********************\n\n"
748 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
749 "Preprocessed source(s) and associated run script(s) are located at:";
Justin Bognerbc89b182014-10-20 21:20:27 +0000750
Justin Bogner659ecc32014-10-20 22:47:23 +0000751 SmallString<128> VFS;
752 for (const char *TempFile : TempFiles) {
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000753 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
Justin Bogner659ecc32014-10-20 22:47:23 +0000754 if (StringRef(TempFile).endswith(".cache")) {
755 // In some cases (modules) we'll dump extra data to help with reproducing
756 // the crash into a directory next to the output.
757 VFS = llvm::sys::path::filename(TempFile);
758 llvm::sys::path::append(VFS, "vfs", "vfs.yaml");
759 }
760 }
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000761
762 // Assume associated files are based off of the first temporary file.
Justin Bogner25645152014-10-21 17:24:44 +0000763 CrashReportInfo CrashInfo(TempFiles[0], VFS);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000764
Justin Bogner25645152014-10-21 17:24:44 +0000765 std::string Script = CrashInfo.Filename.rsplit('.').first.str() + ".sh";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000766 std::error_code EC;
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000767 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl);
768 if (EC) {
769 Diag(clang::diag::note_drv_command_failed_diag_msg)
770 << "Error generating run script: " + Script + " " + EC.message();
771 } else {
Justin Bogner42220ed2015-03-12 00:14:35 +0000772 ScriptOS << "# Crash reproducer for " << getClangFullVersion() << "\n"
Justin Bognered9cbe02015-07-09 06:58:31 +0000773 << "# Driver args: ";
774 printArgList(ScriptOS, C.getInputArgs());
775 ScriptOS << "# Original command: ";
Justin Bogner42220ed2015-03-12 00:14:35 +0000776 Cmd.Print(ScriptOS, "\n", /*Quote=*/true);
Justin Bogner33bdbc62014-10-21 18:03:08 +0000777 Cmd.Print(ScriptOS, "\n", /*Quote=*/true, &CrashInfo);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000778 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
Justin Bognerbc89b182014-10-20 21:20:27 +0000779 }
Saleem Abdulrasool3661a822015-01-12 02:33:09 +0000780
781 for (const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file,
782 options::OPT_frewrite_map_file_EQ))
783 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
784
Justin Bognerbc89b182014-10-20 21:20:27 +0000785 Diag(clang::diag::note_drv_command_failed_diag_msg)
786 << "\n\n********************";
Chad Rosierbe10f982011-08-02 17:58:04 +0000787}
788
Justin Bogner0cd92482015-07-02 22:52:08 +0000789void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) {
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000790 // Since commandLineFitsWithinSystemLimits() may underestimate system's capacity
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000791 // if the tool does not support response files, there is a chance/ that things
792 // will just work without a response file, so we silently just skip it.
Justin Bogner0cd92482015-07-02 22:52:08 +0000793 if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None ||
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000794 llvm::sys::commandLineFitsWithinSystemLimits(Cmd.getExecutable(), Cmd.getArguments()))
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000795 return;
796
797 std::string TmpName = GetTemporaryPath("response", "txt");
Justin Bogner0cd92482015-07-02 22:52:08 +0000798 Cmd.setResponseFile(
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000799 C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str())));
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000800}
801
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000802int Driver::ExecuteCompilation(
803 Compilation &C,
804 SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) {
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000805 // Just print if -### was present.
806 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Hans Wennborgb212b342013-09-12 18:23:34 +0000807 C.getJobs().Print(llvm::errs(), "\n", true);
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000808 return 0;
809 }
810
811 // If there were errors building the compilation, quit now.
Chad Rosierbe10f982011-08-02 17:58:04 +0000812 if (Diags.hasErrorOccurred())
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000813 return 1;
814
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000815 // Set up response file names for each command, if necessary
Justin Bogner0cd92482015-07-02 22:52:08 +0000816 for (auto &Job : C.getJobs())
817 setUpResponseFiles(C, Job);
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000818
Justin Bogner0cd92482015-07-02 22:52:08 +0000819 C.ExecuteJobs(C.getJobs(), FailingCommands);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000820
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000821 // Remove temp files.
822 C.CleanupFileList(C.getTempFiles());
823
Daniel Dunbar07494792010-05-22 00:37:20 +0000824 // If the command succeeded, we are done.
Chad Rosierdd60e092013-01-29 20:15:05 +0000825 if (FailingCommands.empty())
826 return 0;
Daniel Dunbar07494792010-05-22 00:37:20 +0000827
Chad Rosierdd60e092013-01-29 20:15:05 +0000828 // Otherwise, remove result files and print extra information about abnormal
829 // failures.
Douglas Katzman6bbffc42015-06-25 18:51:37 +0000830 for (const auto &CmdPair : FailingCommands) {
831 int Res = CmdPair.first;
832 const Command *FailingCommand = CmdPair.second;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000833
Chad Rosierdd60e092013-01-29 20:15:05 +0000834 // Remove result files if we're not saving temps.
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000835 if (!isSaveTempsEnabled()) {
Chad Rosierdd60e092013-01-29 20:15:05 +0000836 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
837 C.CleanupFileMap(C.getResultFiles(), JA, true);
838
839 // Failure result files are valid unless we crashed.
840 if (Res < 0)
841 C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
842 }
843
844 // Print extra information about abnormal failures, if possible.
845 //
846 // This is ad-hoc, but we don't want to be excessively noisy. If the result
Justin Bogner5aaf2e72014-06-26 20:59:36 +0000847 // status was 1, assume the command failed normally. In particular, if it
Chad Rosierdd60e092013-01-29 20:15:05 +0000848 // was the compiler then assume it gave a reasonable error code. Failures
849 // in other tools are less common, and they generally have worse
850 // diagnostics, so always print the diagnostic there.
851 const Tool &FailingTool = FailingCommand->getCreator();
852
853 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
854 // FIXME: See FIXME above regarding result code interpretation.
855 if (Res < 0)
856 Diag(clang::diag::err_drv_command_signalled)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000857 << FailingTool.getShortName();
Chad Rosierdd60e092013-01-29 20:15:05 +0000858 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000859 Diag(clang::diag::err_drv_command_failed) << FailingTool.getShortName()
860 << Res;
Chad Rosierdd60e092013-01-29 20:15:05 +0000861 }
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000862 }
Chad Rosierdd60e092013-01-29 20:15:05 +0000863 return 0;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000864}
865
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000866void Driver::PrintHelp(bool ShowHidden) const {
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000867 unsigned IncludedFlagsBitmask;
868 unsigned ExcludedFlagsBitmask;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +0000869 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000870 getIncludeExcludeOptionFlagMasks();
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000871
872 ExcludedFlagsBitmask |= options::NoDriverOption;
873 if (!ShowHidden)
874 ExcludedFlagsBitmask |= HelpHidden;
875
876 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
877 IncludedFlagsBitmask, ExcludedFlagsBitmask);
Daniel Dunbar7c925282009-03-31 21:38:17 +0000878}
879
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000880void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000881 // FIXME: The following handlers should use a callback mechanism, we don't
882 // know what the client would like to do.
Ted Kremenek4c0df3d2010-01-23 02:11:34 +0000883 OS << getClangFullVersion() << '\n';
Daniel Dunbarb10248802009-03-26 16:09:13 +0000884 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000885 OS << "Target: " << TC.getTripleString() << '\n';
Daniel Dunbar10978e42009-06-16 23:32:58 +0000886
887 // Print the threading model.
Jonathan Roelofsb140a102014-10-03 21:57:44 +0000888 if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) {
889 // Don't print if the ToolChain would have barfed on it already
890 if (TC.isThreadModelSupported(A->getValue()))
891 OS << "Thread model: " << A->getValue();
892 } else
893 OS << "Thread model: " << TC.getThreadModel();
894 OS << '\n';
Chandler Carruth9ade6a92015-08-05 17:07:33 +0000895
896 // Print out the install directory.
897 OS << "InstalledDir: " << InstalledDir << '\n';
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000898}
899
Chris Lattner86ed5b02010-05-05 05:53:24 +0000900/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
901/// option.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000902static void PrintDiagnosticCategories(raw_ostream &OS) {
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000903 // Skip the empty category.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000904 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max;
905 ++i)
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000906 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
Chris Lattner86ed5b02010-05-05 05:53:24 +0000907}
908
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000909bool Driver::HandleImmediateArgs(const Compilation &C) {
Daniel Dunbar18974bd2010-06-11 22:00:19 +0000910 // The order these options are handled in gcc is all over the place, but we
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000911 // don't expect inconsistencies w.r.t. that to matter in practice.
Daniel Dunbar7c925282009-03-31 21:38:17 +0000912
Daniel Dunbar1b09e042010-09-17 02:47:28 +0000913 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
914 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
915 return false;
916 }
917
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000918 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
Daniel Dunbare26e5002011-01-12 00:43:47 +0000919 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
920 // return an answer which matches our definition of __VERSION__.
921 //
922 // If we want to return a more correct answer some day, then we should
923 // introduce a non-pedantically GCC compatible mode to Clang in which we
924 // provide sensible definitions for -dumpversion, __VERSION__, etc.
925 llvm::outs() << "4.2.1\n";
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000926 return false;
927 }
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000928
Chris Lattner86ed5b02010-05-05 05:53:24 +0000929 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
930 PrintDiagnosticCategories(llvm::outs());
931 return false;
932 }
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000933
James Molloya3c85b82012-05-01 14:57:16 +0000934 if (C.getArgs().hasArg(options::OPT_help) ||
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000935 C.getArgs().hasArg(options::OPT__help_hidden)) {
936 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +0000937 return false;
938 }
939
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000940 if (C.getArgs().hasArg(options::OPT__version)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000941 // Follow gcc behavior and use stdout for --version and stderr for -v.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000942 PrintVersion(C, llvm::outs());
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000943 return false;
944 }
945
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000946 if (C.getArgs().hasArg(options::OPT_v) ||
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000947 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000948 PrintVersion(C, llvm::errs());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000949 SuppressMissingInputWarning = true;
950 }
951
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000952 const ToolChain &TC = C.getDefaultToolChain();
Chandler Carruth0ae39aa2013-07-30 17:57:09 +0000953
954 if (C.getArgs().hasArg(options::OPT_v))
955 TC.printVerboseInfo(llvm::errs());
956
Daniel Dunbard972e222009-03-20 04:37:21 +0000957 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
958 llvm::outs() << "programs: =";
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000959 bool separator = false;
960 for (const std::string &Path : TC.getProgramPaths()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000961 if (separator)
962 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000963 llvm::outs() << Path;
964 separator = true;
Daniel Dunbard972e222009-03-20 04:37:21 +0000965 }
966 llvm::outs() << "\n";
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000967 llvm::outs() << "libraries: =" << ResourceDir;
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000968
Sebastian Pop980920a2012-04-16 04:16:43 +0000969 StringRef sysroot = C.getSysRoot();
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000970
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000971 for (const std::string &Path : TC.getFilePaths()) {
972 // Always print a separator. ResourceDir was the first item shown.
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000973 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000974 // Interpretation of leading '=' is needed only for NetBSD.
975 if (Path[0] == '=')
Douglas Katzman26eabf62015-06-24 15:10:30 +0000976 llvm::outs() << sysroot << Path.substr(1);
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000977 else
Douglas Katzman51fe7bf2015-06-23 22:43:50 +0000978 llvm::outs() << Path;
Daniel Dunbard972e222009-03-20 04:37:21 +0000979 }
980 llvm::outs() << "\n";
Daniel Dunbar7c925282009-03-31 21:38:17 +0000981 return false;
Daniel Dunbard972e222009-03-20 04:37:21 +0000982 }
983
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000984 // FIXME: The following handlers should use a callback mechanism, we don't
985 // know what the client would like to do.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000986 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000987 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000988 return false;
989 }
990
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000991 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000992 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000993 return false;
994 }
995
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000996 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000997 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000998 return false;
999 }
1000
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +00001001 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +00001002 for (const Multilib &Multilib : TC.getMultilibs())
1003 llvm::outs() << Multilib << "\n";
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +00001004 return false;
1005 }
1006
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001007 if (C.getArgs().hasArg(options::OPT_print_multi_directory)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +00001008 for (const Multilib &Multilib : TC.getMultilibs()) {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001009 if (Multilib.gccSuffix().empty())
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001010 llvm::outs() << ".\n";
1011 else {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001012 StringRef Suffix(Multilib.gccSuffix());
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001013 assert(Suffix.front() == '/');
1014 llvm::outs() << Suffix.substr(1) << "\n";
1015 }
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001016 }
Jonathan Roelofs0e7ec602014-02-12 01:29:25 +00001017 return false;
1018 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001019 return true;
1020}
1021
Douglas Katzmanfd528672015-06-11 15:05:22 +00001022// Display an action graph human-readably. Action A is the "sink" node
1023// and latest-occuring action. Traversal is in pre-order, visiting the
1024// inputs to each action before printing the action itself.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001025static unsigned PrintActions1(const Compilation &C, Action *A,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001026 std::map<Action *, unsigned> &Ids) {
Douglas Katzmanfd528672015-06-11 15:05:22 +00001027 if (Ids.count(A)) // A was already visited.
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001028 return Ids[A];
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001029
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001030 std::string str;
1031 llvm::raw_string_ostream os(str);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001032
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001033 os << Action::getClassName(A->getKind()) << ", ";
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001034 if (InputAction *IA = dyn_cast<InputAction>(A)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001035 os << "\"" << IA->getInputArg().getValue() << "\"";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001036 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001037 os << '"' << BIA->getArchName() << '"' << ", {"
Nico Weber5a459f82016-02-23 19:30:43 +00001038 << PrintActions1(C, *BIA->input_begin(), Ids) << "}";
Samuel Antaod06239d2016-07-15 23:13:27 +00001039 } else if (OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1040 bool IsFirst = true;
1041 OA->doOnEachDependence(
1042 [&](Action *A, const ToolChain *TC, const char *BoundArch) {
1043 // E.g. for two CUDA device dependences whose bound arch is sm_20 and
1044 // sm_35 this will generate:
1045 // "cuda-device" (nvptx64-nvidia-cuda:sm_20) {#ID}, "cuda-device"
1046 // (nvptx64-nvidia-cuda:sm_35) {#ID}
1047 if (!IsFirst)
1048 os << ", ";
1049 os << '"';
1050 if (TC)
1051 os << A->getOffloadingKindPrefix();
1052 else
1053 os << "host";
1054 os << " (";
1055 os << TC->getTriple().normalize();
1056
1057 if (BoundArch)
1058 os << ":" << BoundArch;
1059 os << ")";
1060 os << '"';
1061 os << " {" << PrintActions1(C, A, Ids) << "}";
1062 IsFirst = false;
1063 });
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001064 } else {
Samuel Antaod06239d2016-07-15 23:13:27 +00001065 const ActionList *AL = &A->getInputs();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001066
Artem Belevich23256752015-09-22 17:23:09 +00001067 if (AL->size()) {
1068 const char *Prefix = "{";
1069 for (Action *PreRequisite : *AL) {
1070 os << Prefix << PrintActions1(C, PreRequisite, Ids);
1071 Prefix = ", ";
1072 }
1073 os << "}";
1074 } else
1075 os << "{}";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001076 }
1077
Samuel Antaod06239d2016-07-15 23:13:27 +00001078 // Append offload info for all options other than the offloading action
1079 // itself (e.g. (cuda-device, sm_20) or (cuda-host)).
1080 std::string offload_str;
1081 llvm::raw_string_ostream offload_os(offload_str);
1082 if (!isa<OffloadAction>(A)) {
1083 auto S = A->getOffloadingKindPrefix();
1084 if (!S.empty()) {
1085 offload_os << ", (" << S;
1086 if (A->getOffloadingArch())
1087 offload_os << ", " << A->getOffloadingArch();
1088 offload_os << ")";
1089 }
1090 }
1091
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001092 unsigned Id = Ids.size();
1093 Ids[A] = Id;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001094 llvm::errs() << Id << ": " << os.str() << ", "
Samuel Antaod06239d2016-07-15 23:13:27 +00001095 << types::getTypeName(A->getType()) << offload_os.str() << "\n";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001096
1097 return Id;
1098}
1099
Douglas Katzmanfd528672015-06-11 15:05:22 +00001100// Print the action graphs in a compilation C.
1101// For example "clang -c file1.c file2.c" is composed of two subgraphs.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001102void Driver::PrintActions(const Compilation &C) const {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001103 std::map<Action *, unsigned> Ids;
1104 for (Action *A : C.getActions())
1105 PrintActions1(C, A, Ids);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001106}
1107
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +00001108/// \brief Check whether the given input tree contains any compilation or
1109/// assembly actions.
1110static bool ContainsCompileOrAssembleAction(const Action *A) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001111 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
Bob Wilson23a55f12014-12-21 07:00:00 +00001112 isa<AssembleJobAction>(A))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001113 return true;
1114
Nico Weber5a459f82016-02-23 19:30:43 +00001115 for (const Action *Input : A->inputs())
Nico Weberfb80f962015-09-19 21:36:51 +00001116 if (ContainsCompileOrAssembleAction(Input))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001117 return true;
1118
1119 return false;
1120}
1121
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00001122void Driver::BuildUniversalActions(Compilation &C, const ToolChain &TC,
1123 const InputList &BAInputs) const {
1124 DerivedArgList &Args = C.getArgs();
1125 ActionList &Actions = C.getActions();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001126 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
1127 // Collect the list of architectures. Duplicates are allowed, but should only
1128 // be handled once (in the order seen).
Daniel Dunbare5dc4822009-03-13 20:33:35 +00001129 llvm::StringSet<> ArchNames;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001130 SmallVector<const char *, 4> Archs;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001131 for (Arg *A : Args) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001132 if (A->getOption().matches(options::OPT_arch)) {
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001133 // Validate the option here; we don't save the type here because its
1134 // particular spelling may participate in other driver choices.
1135 llvm::Triple::ArchType Arch =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001136 tools::darwin::getArchTypeForMachOArchName(A->getValue());
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001137 if (Arch == llvm::Triple::UnknownArch) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001138 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001139 continue;
1140 }
1141
Daniel Dunbar2da02722009-03-19 07:55:12 +00001142 A->claim();
David Blaikie61b86d42014-11-19 02:56:13 +00001143 if (ArchNames.insert(A->getValue()).second)
Richard Smithbd55daf2012-11-01 04:30:05 +00001144 Archs.push_back(A->getValue());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001145 }
1146 }
1147
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001148 // When there is no explicit arch for this platform, make sure we still bind
1149 // the architecture (to the default) so that -Xarch_ is handled correctly.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001150 if (!Archs.size())
Daniel Dunbarc3bd9f52012-11-08 03:38:26 +00001151 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001152
Daniel Dunbarf479c122009-03-12 18:40:18 +00001153 ActionList SingleActions;
Justin Lebar0f3474c2016-02-11 02:00:50 +00001154 BuildActions(C, Args, BAInputs, SingleActions);
Daniel Dunbarf479c122009-03-12 18:40:18 +00001155
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001156 // Add in arch bindings for every top level action, as well as lipo and
1157 // dsymutil steps if needed.
Nico Weberfb80f962015-09-19 21:36:51 +00001158 for (Action* Act : SingleActions) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001159 // Make sure we can lipo this kind of output. If not (and it is an actual
1160 // output) then we disallow, since we can't create an output file with the
1161 // right name without overwriting it. We could remove this oddity by just
1162 // changing the output names to include the arch, which would also fix
Daniel Dunbarf479c122009-03-12 18:40:18 +00001163 // -save-temps. Compatibility wins for now.
1164
Daniel Dunbare2ca3bd2009-03-13 17:46:02 +00001165 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
Daniel Dunbarf479c122009-03-12 18:40:18 +00001166 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001167 << types::getTypeName(Act->getType());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001168
1169 ActionList Inputs;
Justin Lebar41094612016-01-11 23:07:27 +00001170 for (unsigned i = 0, e = Archs.size(); i != e; ++i)
1171 Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i]));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001172
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001173 // Lipo if necessary, we do it this way because we need to set the arch flag
1174 // so that -Xarch_ gets overwritten.
Daniel Dunbarf479c122009-03-12 18:40:18 +00001175 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1176 Actions.append(Inputs.begin(), Inputs.end());
1177 else
Justin Lebar41094612016-01-11 23:07:27 +00001178 Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType()));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001179
Eric Christopher65c05fa2012-02-06 19:43:51 +00001180 // Handle debug info queries.
1181 Arg *A = Args.getLastArg(options::OPT_g_Group);
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001182 if (A && !A->getOption().matches(options::OPT_g0) &&
1183 !A->getOption().matches(options::OPT_gstabs) &&
1184 ContainsCompileOrAssembleAction(Actions.back())) {
Chad Rosier62135492012-07-09 17:31:28 +00001185
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001186 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
1187 // have a compile input. We need to run 'dsymutil' ourselves in such cases
Eric Christopher776c26f2013-01-28 17:39:03 +00001188 // because the debug info will refer to a temporary object file which
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001189 // will be removed at the end of the compilation process.
1190 if (Act->getType() == types::TY_Image) {
1191 ActionList Inputs;
1192 Inputs.push_back(Actions.back());
1193 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001194 Actions.push_back(
1195 C.MakeAction<DsymutilJobAction>(Inputs, types::TY_dSYM));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001196 }
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001197
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00001198 // Verify the debug info output.
Alp Tokere9d2bfc2014-01-17 02:06:23 +00001199 if (Args.hasArg(options::OPT_verify_debug_info)) {
Justin Lebar41094612016-01-11 23:07:27 +00001200 Action* LastAction = Actions.back();
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001201 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001202 Actions.push_back(C.MakeAction<VerifyDebugInfoJobAction>(
1203 LastAction, types::TY_Nothing));
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001204 }
1205 }
Daniel Dunbarf479c122009-03-12 18:40:18 +00001206 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001207}
1208
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001209/// \brief Check that the file referenced by Value exists. If it doesn't,
1210/// issue a diagnostic and return false.
Alp Toker8c8a8752013-12-03 06:53:35 +00001211static bool DiagnoseInputExistence(const Driver &D, const DerivedArgList &Args,
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001212 StringRef Value, types::ID Ty) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001213 if (!D.getCheckInputsExist())
1214 return true;
1215
1216 // stdin always exists.
1217 if (Value == "-")
1218 return true;
1219
1220 SmallString<64> Path(Value);
1221 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00001222 if (!llvm::sys::path::is_absolute(Path)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001223 SmallString<64> Directory(WorkDir->getValue());
1224 llvm::sys::path::append(Directory, Value);
1225 Path.assign(Directory);
1226 }
1227 }
1228
1229 if (llvm::sys::fs::exists(Twine(Path)))
1230 return true;
1231
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001232 if (D.IsCLMode()) {
1233 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1234 llvm::sys::Process::FindInEnvPath("LIB", Value))
1235 return true;
1236
1237 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1238 // Arguments to the /link flag might cause the linker to search for object
1239 // and library files in paths we don't know about. Don't error in such
1240 // cases.
1241 return true;
1242 }
1243 }
Hans Wennborg23d26a32014-06-18 17:21:50 +00001244
Yaron Keren92e1b622015-03-18 10:17:07 +00001245 D.Diag(clang::diag::err_drv_no_such_file) << Path;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001246 return false;
1247}
1248
Chad Rosierecdede82011-08-12 22:08:57 +00001249// Construct a the list of inputs and their types.
Hans Wennborg55362852014-05-02 22:55:30 +00001250void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
Chad Rosierecdede82011-08-12 22:08:57 +00001251 InputList &Inputs) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001252 // Track the current user specified (-x) input. We also explicitly track the
1253 // argument used to set the type; we only want to claim the type when we
1254 // actually use it, so we warn about unused -x arguments.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001255 types::ID InputType = types::TY_Nothing;
Craig Topper92fc2df2014-05-17 16:56:41 +00001256 Arg *InputTypeArg = nullptr;
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001257
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001258 // The last /TC or /TP option sets the input type to C or C++ globally.
Ehsan Akhgaric249abb2014-09-12 21:44:24 +00001259 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1260 options::OPT__SLASH_TP)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001261 InputTypeArg = TCTP;
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001262 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001263 ? types::TY_C
1264 : types::TY_CXX;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001265
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001266 arg_iterator it =
1267 Args.filtered_begin(options::OPT__SLASH_TC, options::OPT__SLASH_TP);
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001268 const arg_iterator ie = Args.filtered_end();
1269 Arg *Previous = *it++;
1270 bool ShowNote = false;
1271 while (it != ie) {
Hans Wennborgd9ad0682013-09-11 16:38:41 +00001272 Diag(clang::diag::warn_drv_overriding_flag_option)
1273 << Previous->getSpelling() << (*it)->getSpelling();
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001274 Previous = *it++;
1275 ShowNote = true;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001276 }
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001277 if (ShowNote)
1278 Diag(clang::diag::note_drv_t_option_is_global);
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001279
1280 // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1281 assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1282 }
1283
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001284 for (Arg *A : Args) {
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001285 if (A->getOption().getKind() == Option::InputClass) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001286 const char *Value = A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001287 types::ID Ty = types::TY_INVALID;
1288
1289 // Infer the input type if necessary.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001290 if (InputType == types::TY_Nothing) {
1291 // If there was an explicit arg for this, claim it.
1292 if (InputTypeArg)
1293 InputTypeArg->claim();
1294
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001295 // stdin must be handled specially.
1296 if (memcmp(Value, "-", 2) == 0) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001297 // If running with -E, treat as a C input (this changes the builtin
1298 // macros, for example). This may be overridden by -ObjC below.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001299 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001300 // Otherwise emit an error but still use a valid type to avoid
1301 // spurious errors (e.g., no inputs).
Hans Wennborg70850d82013-07-18 20:29:38 +00001302 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
Hans Wennborgcfdd8b52014-01-29 01:04:40 +00001303 Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1304 : clang::diag::err_drv_unknown_stdin_type);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001305 Ty = types::TY_C;
1306 } else {
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001307 // Otherwise lookup by extension.
1308 // Fallback is C if invoked as C preprocessor or Object otherwise.
1309 // We use a host hook here because Darwin at least has its own
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001310 // idea of what .s is.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001311 if (const char *Ext = strrchr(Value, '.'))
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +00001312 Ty = TC.LookupTypeForExtension(Ext + 1);
Daniel Dunbarea9f0322009-03-20 23:39:23 +00001313
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001314 if (Ty == types::TY_INVALID) {
Hans Wennborg70850d82013-07-18 20:29:38 +00001315 if (CCCIsCPP())
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001316 Ty = types::TY_C;
1317 else
1318 Ty = types::TY_Object;
1319 }
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001320
1321 // If the driver is invoked as C++ compiler (like clang++ or c++) it
1322 // should autodetect some input files as C++ for g++ compatibility.
Hans Wennborg70850d82013-07-18 20:29:38 +00001323 if (CCCIsCXX()) {
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001324 types::ID OldTy = Ty;
1325 Ty = types::lookupCXXTypeForCType(Ty);
1326
1327 if (Ty != OldTy)
1328 Diag(clang::diag::warn_drv_treating_input_as_cxx)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001329 << getTypeName(OldTy) << getTypeName(Ty);
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001330 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001331 }
1332
Daniel Dunbar82b22102009-05-18 21:47:54 +00001333 // -ObjC and -ObjC++ override the default language, but only for "source
1334 // files". We just treat everything that isn't a linker input as a
1335 // source file.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001336 //
Daniel Dunbar82b22102009-05-18 21:47:54 +00001337 // FIXME: Clean this up if we move the phase sequence into the type.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001338 if (Ty != types::TY_Object) {
1339 if (Args.hasArg(options::OPT_ObjC))
1340 Ty = types::TY_ObjC;
1341 else if (Args.hasArg(options::OPT_ObjCXX))
1342 Ty = types::TY_ObjCXX;
1343 }
1344 } else {
1345 assert(InputTypeArg && "InputType set w/o InputTypeArg");
Ehsan Akhgari7e954ea2014-09-12 18:15:10 +00001346 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1347 // If emulating cl.exe, make sure that /TC and /TP don't affect input
1348 // object files.
1349 const char *Ext = strrchr(Value, '.');
1350 if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
1351 Ty = types::TY_Object;
1352 }
1353 if (Ty == types::TY_INVALID) {
1354 Ty = InputType;
1355 InputTypeArg->claim();
1356 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001357 }
1358
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001359 if (DiagnoseInputExistence(*this, Args, Value, Ty))
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001360 Inputs.push_back(std::make_pair(Ty, A));
1361
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001362 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1363 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001364 if (DiagnoseInputExistence(*this, Args, Value, types::TY_C)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001365 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1366 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1367 }
1368 A->claim();
1369 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1370 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001371 if (DiagnoseInputExistence(*this, Args, Value, types::TY_CXX)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001372 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1373 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1374 }
1375 A->claim();
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001376 } else if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001377 // Just treat as object type, we could make a special type for this if
1378 // necessary.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001379 Inputs.push_back(std::make_pair(types::TY_Object, A));
1380
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001381 } else if (A->getOption().matches(options::OPT_x)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001382 InputTypeArg = A;
Richard Smithbd55daf2012-11-01 04:30:05 +00001383 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
Chad Rosier706c2352012-04-07 00:01:31 +00001384 A->claim();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001385
1386 // Follow gcc behavior and treat as linker input for invalid -x
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001387 // options. Its not clear why we shouldn't just revert to unknown; but
Michael J. Spencer1a4fe8c2010-12-17 21:22:33 +00001388 // this isn't very important, we might as well be bug compatible.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001389 if (!InputType) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001390 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001391 InputType = types::TY_Object;
1392 }
1393 }
1394 }
Hans Wennborg70850d82013-07-18 20:29:38 +00001395 if (CCCIsCPP() && Inputs.empty()) {
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001396 // If called as standalone preprocessor, stdin is processed
1397 // if no other input is present.
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001398 Arg *A = MakeInputArg(Args, Opts, "-");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001399 Inputs.push_back(std::make_pair(types::TY_C, A));
1400 }
Chad Rosierecdede82011-08-12 22:08:57 +00001401}
1402
Artem Belevichf8144ab2015-08-27 18:10:41 +00001403// For each unique --cuda-gpu-arch= argument creates a TY_CUDA_DEVICE
1404// input action and then wraps each in CudaDeviceAction paired with
1405// appropriate GPU arch name. In case of partial (i.e preprocessing
1406// only) or device-only compilation, each device action is added to /p
1407// Actions and /p Current is released. Otherwise the function creates
1408// and returns a new CudaHostAction which wraps /p Current and device
1409// side actions.
Justin Lebar41094612016-01-11 23:07:27 +00001410static Action *buildCudaActions(Compilation &C, DerivedArgList &Args,
1411 const Arg *InputArg, Action *HostAction,
1412 ActionList &Actions) {
Justin Lebardc3c5042016-04-19 02:27:07 +00001413 Arg *PartialCompilationArg = Args.getLastArg(
1414 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
1415 options::OPT_cuda_compile_host_device);
1416 bool CompileHostOnly =
1417 PartialCompilationArg &&
1418 PartialCompilationArg->getOption().matches(options::OPT_cuda_host_only);
1419 bool CompileDeviceOnly =
1420 PartialCompilationArg &&
1421 PartialCompilationArg->getOption().matches(options::OPT_cuda_device_only);
Artem Belevichf981e30b2016-08-02 22:37:47 +00001422 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
1423 assert(HostTC && "No toolchain for host compilation.");
1424 if (HostTC->getTriple().isNVPTX()) {
1425 // We do not support targeting NVPTX for host compilation. Throw
1426 // an error and abort pipeline construction early so we don't trip
1427 // asserts that assume device-side compilation.
1428 C.getDriver().Diag(diag::err_drv_cuda_nvptx_host);
1429 return nullptr;
1430 }
Justin Lebardc3c5042016-04-19 02:27:07 +00001431
Samuel Antaod06239d2016-07-15 23:13:27 +00001432 if (CompileHostOnly) {
Artem Belevichf981e30b2016-08-02 22:37:47 +00001433 OffloadAction::HostDependence HDep(*HostAction, *HostTC,
1434 /*BoundArch=*/nullptr, Action::OFK_Cuda);
Samuel Antaod06239d2016-07-15 23:13:27 +00001435 return C.MakeAction<OffloadAction>(HDep);
1436 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001437
1438 // Collect all cuda_gpu_arch parameters, removing duplicates.
Justin Lebar62907612016-07-06 21:21:39 +00001439 SmallVector<CudaArch, 4> GpuArchList;
1440 llvm::SmallSet<CudaArch, 4> GpuArchs;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001441 for (Arg *A : Args) {
Justin Lebar23bcef92016-01-08 19:04:11 +00001442 if (!A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
1443 continue;
1444 A->claim();
Justin Lebar7bf77982016-01-11 23:27:13 +00001445
Justin Lebar62907612016-07-06 21:21:39 +00001446 const auto &ArchStr = A->getValue();
1447 CudaArch Arch = StringToCudaArch(ArchStr);
1448 if (Arch == CudaArch::UNKNOWN)
1449 C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
1450 else if (GpuArchs.insert(Arch).second)
Justin Lebar7bf77982016-01-11 23:27:13 +00001451 GpuArchList.push_back(Arch);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001452 }
1453
1454 // Default to sm_20 which is the lowest common denominator for supported GPUs.
1455 // sm_20 code should work correctly, if suboptimally, on all newer GPUs.
1456 if (GpuArchList.empty())
Justin Lebar62907612016-07-06 21:21:39 +00001457 GpuArchList.push_back(CudaArch::SM_20);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001458
1459 // Replicate inputs for each GPU architecture.
1460 Driver::InputList CudaDeviceInputs;
Artem Belevich5bde4e02015-07-20 20:02:54 +00001461 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001462 CudaDeviceInputs.push_back(std::make_pair(types::TY_CUDA_DEVICE, InputArg));
1463
1464 // Build actions for all device inputs.
1465 ActionList CudaDeviceActions;
Justin Lebar0f3474c2016-02-11 02:00:50 +00001466 C.getDriver().BuildActions(C, Args, CudaDeviceInputs, CudaDeviceActions);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001467 assert(GpuArchList.size() == CudaDeviceActions.size() &&
1468 "Failed to create actions for all devices");
1469
1470 // Check whether any of device actions stopped before they could generate PTX.
Justin Lebar23bcef92016-01-08 19:04:11 +00001471 bool PartialCompilation =
1472 llvm::any_of(CudaDeviceActions, [](const Action *a) {
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001473 return a->getKind() != Action::AssembleJobClass;
Justin Lebar23bcef92016-01-08 19:04:11 +00001474 });
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001475
Samuel Antaod06239d2016-07-15 23:13:27 +00001476 const ToolChain *CudaTC = C.getSingleOffloadToolChain<Action::OFK_Cuda>();
1477
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001478 // Figure out what to do with device actions -- pass them as inputs to the
1479 // host action or run each of them independently.
Justin Lebardc3c5042016-04-19 02:27:07 +00001480 if (PartialCompilation || CompileDeviceOnly) {
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001481 // In case of partial or device-only compilation results of device actions
1482 // are not consumed by the host action device actions have to be added to
1483 // top-level actions list with AtTopLevel=true and run independently.
1484
1485 // -o is ambiguous if we have more than one top-level action.
1486 if (Args.hasArg(options::OPT_o) &&
Justin Lebardc3c5042016-04-19 02:27:07 +00001487 (!CompileDeviceOnly || GpuArchList.size() > 1)) {
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00001488 C.getDriver().Diag(
1489 clang::diag::err_drv_output_argument_with_multiple_files);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001490 return nullptr;
1491 }
1492
Samuel Antaod06239d2016-07-15 23:13:27 +00001493 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
1494 OffloadAction::DeviceDependences DDep;
1495 DDep.add(*CudaDeviceActions[I], *CudaTC, CudaArchToString(GpuArchList[I]),
1496 Action::OFK_Cuda);
1497 Actions.push_back(
1498 C.MakeAction<OffloadAction>(DDep, CudaDeviceActions[I]->getType()));
1499 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001500 // Kill host action in case of device-only compilation.
Justin Lebardc3c5042016-04-19 02:27:07 +00001501 if (CompileDeviceOnly)
Justin Lebar41094612016-01-11 23:07:27 +00001502 return nullptr;
Artem Belevichdb35a3e2015-07-20 21:59:31 +00001503 return HostAction;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001504 }
Artem Belevich5bde4e02015-07-20 20:02:54 +00001505
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001506 // If we're not a partial or device-only compilation, we compile each arch to
1507 // ptx and assemble to cubin, then feed the cubin *and* the ptx into a device
1508 // "link" action, which uses fatbinary to combine these cubins into one
1509 // fatbin. The fatbin is then an input to the host compilation.
Artem Belevich5bde4e02015-07-20 20:02:54 +00001510 ActionList DeviceActions;
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001511 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
1512 Action* AssembleAction = CudaDeviceActions[I];
1513 assert(AssembleAction->getType() == types::TY_Object);
1514 assert(AssembleAction->getInputs().size() == 1);
1515
1516 Action* BackendAction = AssembleAction->getInputs()[0];
1517 assert(BackendAction->getType() == types::TY_PP_Asm);
1518
Samuel Antaod06239d2016-07-15 23:13:27 +00001519 for (auto &A : {AssembleAction, BackendAction}) {
1520 OffloadAction::DeviceDependences DDep;
1521 DDep.add(*A, *CudaTC, CudaArchToString(GpuArchList[I]), Action::OFK_Cuda);
1522 DeviceActions.push_back(C.MakeAction<OffloadAction>(DDep, A->getType()));
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001523 }
1524 }
Samuel Antaod06239d2016-07-15 23:13:27 +00001525 auto FatbinAction =
1526 C.MakeAction<LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN);
1527
Artem Belevich5bde4e02015-07-20 20:02:54 +00001528 // Return a new host action that incorporates original host action and all
1529 // device actions.
Artem Belevichf981e30b2016-08-02 22:37:47 +00001530 OffloadAction::HostDependence HDep(*HostAction, *HostTC,
1531 /*BoundArch=*/nullptr, Action::OFK_Cuda);
Samuel Antaod06239d2016-07-15 23:13:27 +00001532 OffloadAction::DeviceDependences DDep;
1533 DDep.add(*FatbinAction, *CudaTC, /*BoundArch=*/nullptr, Action::OFK_Cuda);
1534 return C.MakeAction<OffloadAction>(HDep, DDep);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001535}
1536
Justin Lebar0f3474c2016-02-11 02:00:50 +00001537void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
1538 const InputList &Inputs, ActionList &Actions) const {
Chad Rosierecdede82011-08-12 22:08:57 +00001539 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001540
Daniel Dunbar34c41872009-03-13 00:17:48 +00001541 if (!SuppressMissingInputWarning && Inputs.empty()) {
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001542 Diag(clang::diag::err_drv_no_input_files);
1543 return;
1544 }
1545
Chad Rosier7742b5d2011-07-27 23:36:45 +00001546 Arg *FinalPhaseArg;
1547 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001548
Rafael Espindolae8025642013-08-25 14:27:09 +00001549 if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) {
1550 Diag(clang::diag::err_drv_emit_llvm_link);
1551 }
1552
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001553 // Reject -Z* at the top level, these options should never have been exposed
1554 // by gcc.
Daniel Dunbardd765242009-03-26 16:12:09 +00001555 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Daniel Dunbar0e759942009-03-20 06:14:23 +00001556 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001557
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001558 // Diagnose misuse of /Fo.
1559 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001560 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00001561 if (Inputs.size() > 1 && !V.empty() &&
1562 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001563 // Check whether /Fo tries to name an output file for multiple inputs.
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001564 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001565 << A->getSpelling() << V;
Hans Wennborg13b7fe72013-08-12 23:26:25 +00001566 Args.eraseArg(options::OPT__SLASH_Fo);
1567 }
1568 }
1569
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001570 // Diagnose misuse of /Fa.
1571 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
1572 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00001573 if (Inputs.size() > 1 && !V.empty() &&
1574 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001575 // Check whether /Fa tries to name an asm file for multiple inputs.
1576 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001577 << A->getSpelling() << V;
Hans Wennborg9c1659b2013-10-18 22:49:04 +00001578 Args.eraseArg(options::OPT__SLASH_Fa);
1579 }
1580 }
1581
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00001582 // Diagnose misuse of /o.
1583 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
1584 if (A->getValue()[0] == '\0') {
1585 // It has to have a value.
1586 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
1587 Args.eraseArg(options::OPT__SLASH_o);
1588 }
1589 }
1590
Nico Weber2ca4be92016-03-01 23:16:44 +00001591 // Diagnose unsupported forms of /Yc /Yu. Ignore /Yc/Yu for now if:
1592 // * no filename after it
1593 // * both /Yc and /Yu passed but with different filenames
1594 // * corresponding file not also passed as /FI
1595 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
1596 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
1597 if (YcArg && YcArg->getValue()[0] == '\0') {
1598 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
1599 Args.eraseArg(options::OPT__SLASH_Yc);
1600 YcArg = nullptr;
1601 }
1602 if (YuArg && YuArg->getValue()[0] == '\0') {
1603 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
1604 Args.eraseArg(options::OPT__SLASH_Yu);
1605 YuArg = nullptr;
1606 }
1607 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
1608 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
1609 Args.eraseArg(options::OPT__SLASH_Yc);
1610 Args.eraseArg(options::OPT__SLASH_Yu);
1611 YcArg = YuArg = nullptr;
1612 }
1613 if (YcArg || YuArg) {
1614 StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
1615 bool FoundMatchingInclude = false;
1616 for (const Arg *Inc : Args.filtered(options::OPT_include)) {
1617 // FIXME: Do case-insensitive matching and consider / and \ as equal.
1618 if (Inc->getValue() == Val)
1619 FoundMatchingInclude = true;
1620 }
1621 if (!FoundMatchingInclude) {
1622 Diag(clang::diag::warn_drv_ycyu_no_fi_arg_clang_cl)
1623 << (YcArg ? YcArg : YuArg)->getSpelling();
1624 Args.eraseArg(options::OPT__SLASH_Yc);
1625 Args.eraseArg(options::OPT__SLASH_Yu);
1626 YcArg = YuArg = nullptr;
1627 }
1628 }
1629 if (YcArg && Inputs.size() > 1) {
1630 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
1631 Args.eraseArg(options::OPT__SLASH_Yc);
1632 YcArg = nullptr;
1633 }
1634 if (Args.hasArg(options::OPT__SLASH_Y_)) {
1635 // /Y- disables all pch handling. Rather than check for it everywhere,
1636 // just remove clang-cl pch-related flags here.
1637 Args.eraseArg(options::OPT__SLASH_Fp);
1638 Args.eraseArg(options::OPT__SLASH_Yc);
1639 Args.eraseArg(options::OPT__SLASH_Yu);
1640 YcArg = YuArg = nullptr;
1641 }
Nico Weber2ca4be92016-03-01 23:16:44 +00001642
Samuel Antaod06239d2016-07-15 23:13:27 +00001643 // Track the host offload kinds used on this compilation.
1644 unsigned CompilationActiveOffloadHostKinds = 0u;
1645
Daniel Dunbar65229332009-03-13 11:38:42 +00001646 // Construct the actions to perform.
1647 ActionList LinkerInputs;
Alp Toker965f8822013-11-27 05:22:15 +00001648
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001649 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
Artem Belevich5bde4e02015-07-20 20:02:54 +00001650 for (auto &I : Inputs) {
1651 types::ID InputType = I.first;
1652 const Arg *InputArg = I.second;
Daniel Dunbar65229332009-03-13 11:38:42 +00001653
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001654 PL.clear();
1655 types::getCompilationPhases(InputType, PL);
Daniel Dunbar65229332009-03-13 11:38:42 +00001656
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001657 // If the first step comes after the final phase we are doing as part of
1658 // this compilation, warn the user about it.
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001659 phases::ID InitialPhase = PL[0];
Daniel Dunbar65229332009-03-13 11:38:42 +00001660 if (InitialPhase > FinalPhase) {
Daniel Dunbaradc5c7c2009-03-19 07:57:08 +00001661 // Claim here to avoid the more general unused warning.
1662 InputArg->claim();
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001663
Daniel Dunbar2db3e732011-04-20 15:44:48 +00001664 // Suppress all unused style warnings with -Qunused-arguments
1665 if (Args.hasArg(options::OPT_Qunused_arguments))
1666 continue;
1667
Richard Smith403f76e2012-08-06 04:09:06 +00001668 // Special case when final phase determined by binary name, rather than
1669 // by a command-line argument with a corresponding Arg.
Hans Wennborg70850d82013-07-18 20:29:38 +00001670 if (CCCIsCPP())
Richard Smith403f76e2012-08-06 04:09:06 +00001671 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001672 << InputArg->getAsString(Args) << getPhaseName(InitialPhase);
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001673 // Special case '-E' warning on a previously preprocessed file to make
1674 // more sense.
Richard Smith403f76e2012-08-06 04:09:06 +00001675 else if (InitialPhase == phases::Compile &&
1676 FinalPhase == phases::Preprocess &&
1677 getPreprocessedType(InputType) == types::TY_INVALID)
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001678 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001679 << InputArg->getAsString(Args) << !!FinalPhaseArg
1680 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001681 else
1682 Diag(clang::diag::warn_drv_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001683 << InputArg->getAsString(Args) << getPhaseName(InitialPhase)
1684 << !!FinalPhaseArg
1685 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar65229332009-03-13 11:38:42 +00001686 continue;
1687 }
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001688
Nico Weberad2d8f32016-04-21 19:59:10 +00001689 if (YcArg) {
1690 // Add a separate precompile phase for the compile phase.
1691 if (FinalPhase >= phases::Compile) {
Richard Smith8cd452d2016-08-30 18:55:16 +00001692 const types::ID HeaderType = lookupHeaderTypeForSourceType(InputType);
Nico Weberad2d8f32016-04-21 19:59:10 +00001693 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PCHPL;
Richard Smith8cd452d2016-08-30 18:55:16 +00001694 types::getCompilationPhases(HeaderType, PCHPL);
Nico Weberad2d8f32016-04-21 19:59:10 +00001695 Arg *PchInputArg = MakeInputArg(Args, Opts, YcArg->getValue());
1696
1697 // Build the pipeline for the pch file.
Richard Smith8cd452d2016-08-30 18:55:16 +00001698 Action *ClangClPch =
1699 C.MakeAction<InputAction>(*PchInputArg, HeaderType);
Nico Weberad2d8f32016-04-21 19:59:10 +00001700 for (phases::ID Phase : PCHPL)
1701 ClangClPch = ConstructPhaseAction(C, Args, Phase, ClangClPch);
1702 assert(ClangClPch);
1703 Actions.push_back(ClangClPch);
1704 // The driver currently exits after the first failed command. This
1705 // relies on that behavior, to make sure if the pch generation fails,
1706 // the main compilation won't run.
1707 }
1708 }
1709
Justin Lebar23bcef92016-01-08 19:04:11 +00001710 phases::ID CudaInjectionPhase =
1711 (phases::Compile < FinalPhase &&
1712 llvm::find(PL, phases::Compile) != PL.end())
1713 ? phases::Compile
1714 : FinalPhase;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001715
Samuel Antaod06239d2016-07-15 23:13:27 +00001716 // Track the host offload kinds used on this input.
1717 unsigned InputActiveOffloadHostKinds = 0u;
1718
Daniel Dunbar65229332009-03-13 11:38:42 +00001719 // Build the pipeline for this file.
Justin Lebar41094612016-01-11 23:07:27 +00001720 Action *Current = C.MakeAction<InputAction>(*InputArg, InputType);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001721 for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
1722 i != e; ++i) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001723 phases::ID Phase = *i;
Daniel Dunbar65229332009-03-13 11:38:42 +00001724
1725 // We are done if this step is past what the user requested.
1726 if (Phase > FinalPhase)
1727 break;
1728
1729 // Queue linker inputs.
1730 if (Phase == phases::Link) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001731 assert((i + 1) == e && "linking must be final compilation step.");
Justin Lebar41094612016-01-11 23:07:27 +00001732 LinkerInputs.push_back(Current);
1733 Current = nullptr;
Daniel Dunbar65229332009-03-13 11:38:42 +00001734 break;
1735 }
1736
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001737 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1738 // encode this in the steps because the intermediate type depends on
1739 // arguments. Just special case here.
Daniel Dunbar13864952009-03-24 20:17:30 +00001740 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1741 continue;
1742
Daniel Dunbar65229332009-03-13 11:38:42 +00001743 // Otherwise construct the appropriate action.
Justin Lebar0f3474c2016-02-11 02:00:50 +00001744 Current = ConstructPhaseAction(C, Args, Phase, Current);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001745
Artem Belevich23256752015-09-22 17:23:09 +00001746 if (InputType == types::TY_CUDA && Phase == CudaInjectionPhase) {
Justin Lebar41094612016-01-11 23:07:27 +00001747 Current = buildCudaActions(C, Args, InputArg, Current, Actions);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001748 if (!Current)
1749 break;
Samuel Antaod06239d2016-07-15 23:13:27 +00001750
1751 // We produced a CUDA action for this input, so the host has to support
1752 // CUDA.
1753 InputActiveOffloadHostKinds |= Action::OFK_Cuda;
1754 CompilationActiveOffloadHostKinds |= Action::OFK_Cuda;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001755 }
1756
Daniel Dunbar65229332009-03-13 11:38:42 +00001757 if (Current->getType() == types::TY_Nothing)
1758 break;
1759 }
1760
Samuel Antaod06239d2016-07-15 23:13:27 +00001761 // If we ended with something, add to the output list. Also, propagate the
1762 // offload information to the top-level host action related with the current
1763 // input.
1764 if (Current) {
1765 if (InputActiveOffloadHostKinds)
1766 Current->propagateHostOffloadInfo(InputActiveOffloadHostKinds,
1767 /*BoundArch=*/nullptr);
Justin Lebar41094612016-01-11 23:07:27 +00001768 Actions.push_back(Current);
Samuel Antaod06239d2016-07-15 23:13:27 +00001769 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001770 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001771
Samuel Antaod06239d2016-07-15 23:13:27 +00001772 // Add a link action if necessary and propagate the offload information for
1773 // the current compilation.
1774 if (!LinkerInputs.empty()) {
Justin Lebar41094612016-01-11 23:07:27 +00001775 Actions.push_back(
1776 C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image));
Samuel Antaod06239d2016-07-15 23:13:27 +00001777 Actions.back()->propagateHostOffloadInfo(CompilationActiveOffloadHostKinds,
1778 /*BoundArch=*/nullptr);
1779 }
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001780
1781 // If we are linking, claim any options which are obviously only used for
1782 // compilation.
Hans Wennborga8ef14f2013-09-17 00:03:41 +00001783 if (FinalPhase == phases::Link && PL.size() == 1) {
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001784 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
Hans Wennborga8ef14f2013-09-17 00:03:41 +00001785 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
1786 }
1787
1788 // Claim ignored clang-cl options.
1789 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
Artem Belevichbaae0932015-07-28 21:01:30 +00001790
Justin Lebardc3c5042016-04-19 02:27:07 +00001791 // Claim --cuda-host-only and --cuda-compile-host-device, which may be passed
1792 // to non-CUDA compilations and should not trigger warnings there.
Artem Belevichbaae0932015-07-28 21:01:30 +00001793 Args.ClaimAllArgs(options::OPT_cuda_host_only);
Justin Lebardc3c5042016-04-19 02:27:07 +00001794 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
Daniel Dunbar65229332009-03-13 11:38:42 +00001795}
1796
Justin Lebar0f3474c2016-02-11 02:00:50 +00001797Action *Driver::ConstructPhaseAction(Compilation &C, const ArgList &Args,
1798 phases::ID Phase, Action *Input) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001799 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
Daniel Dunbar65229332009-03-13 11:38:42 +00001800 // Build the appropriate action.
1801 switch (Phase) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001802 case phases::Link:
1803 llvm_unreachable("link action invalid here.");
Daniel Dunbar65229332009-03-13 11:38:42 +00001804 case phases::Preprocess: {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001805 types::ID OutputTy;
1806 // -{M, MM} alter the output type.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +00001807 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001808 OutputTy = types::TY_Dependencies;
1809 } else {
David Blaikie5d577a22012-06-29 22:03:56 +00001810 OutputTy = Input->getType();
1811 if (!Args.hasFlag(options::OPT_frewrite_includes,
Justin Bognerce8245b2014-06-24 08:01:01 +00001812 options::OPT_fno_rewrite_includes, false) &&
1813 !CCGenDiagnostics)
David Blaikie5d577a22012-06-29 22:03:56 +00001814 OutputTy = types::getPreprocessedType(OutputTy);
Daniel Dunbard67a3222009-03-30 06:36:42 +00001815 assert(OutputTy != types::TY_INVALID &&
1816 "Cannot preprocess this input type!");
1817 }
Justin Lebar41094612016-01-11 23:07:27 +00001818 return C.MakeAction<PreprocessJobAction>(Input, OutputTy);
Daniel Dunbar65229332009-03-13 11:38:42 +00001819 }
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001820 case phases::Precompile: {
Richard Smithdd4ad3d2016-08-30 19:06:26 +00001821 types::ID OutputTy = getPrecompiledType(Input->getType());
1822 assert(OutputTy != types::TY_INVALID &&
1823 "Cannot precompile this input type!");
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001824 if (Args.hasArg(options::OPT_fsyntax_only)) {
1825 // Syntax checks should not emit a PCH file
1826 OutputTy = types::TY_Nothing;
1827 }
Justin Lebar41094612016-01-11 23:07:27 +00001828 return C.MakeAction<PrecompileJobAction>(Input, OutputTy);
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001829 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001830 case phases::Compile: {
David Blaikie486f4402014-08-29 07:25:23 +00001831 if (Args.hasArg(options::OPT_fsyntax_only))
Justin Lebar41094612016-01-11 23:07:27 +00001832 return C.MakeAction<CompileJobAction>(Input, types::TY_Nothing);
David Blaikie486f4402014-08-29 07:25:23 +00001833 if (Args.hasArg(options::OPT_rewrite_objc))
Justin Lebar41094612016-01-11 23:07:27 +00001834 return C.MakeAction<CompileJobAction>(Input, types::TY_RewrittenObjC);
David Blaikie486f4402014-08-29 07:25:23 +00001835 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
Justin Lebar41094612016-01-11 23:07:27 +00001836 return C.MakeAction<CompileJobAction>(Input,
1837 types::TY_RewrittenLegacyObjC);
David Blaikie486f4402014-08-29 07:25:23 +00001838 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
Justin Lebar41094612016-01-11 23:07:27 +00001839 return C.MakeAction<AnalyzeJobAction>(Input, types::TY_Plist);
David Blaikie486f4402014-08-29 07:25:23 +00001840 if (Args.hasArg(options::OPT__migrate))
Justin Lebar41094612016-01-11 23:07:27 +00001841 return C.MakeAction<MigrateJobAction>(Input, types::TY_Remap);
David Blaikie486f4402014-08-29 07:25:23 +00001842 if (Args.hasArg(options::OPT_emit_ast))
Justin Lebar41094612016-01-11 23:07:27 +00001843 return C.MakeAction<CompileJobAction>(Input, types::TY_AST);
David Blaikie486f4402014-08-29 07:25:23 +00001844 if (Args.hasArg(options::OPT_module_file_info))
Justin Lebar41094612016-01-11 23:07:27 +00001845 return C.MakeAction<CompileJobAction>(Input, types::TY_ModuleFile);
David Blaikie486f4402014-08-29 07:25:23 +00001846 if (Args.hasArg(options::OPT_verify_pch))
Justin Lebar41094612016-01-11 23:07:27 +00001847 return C.MakeAction<VerifyPCHJobAction>(Input, types::TY_Nothing);
1848 return C.MakeAction<CompileJobAction>(Input, types::TY_LLVM_BC);
Bob Wilson23a55f12014-12-21 07:00:00 +00001849 }
1850 case phases::Backend: {
Teresa Johnson945bc502015-10-15 20:35:53 +00001851 if (isUsingLTO()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001852 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001853 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
Justin Lebar41094612016-01-11 23:07:27 +00001854 return C.MakeAction<BackendJobAction>(Input, Output);
David Blaikie486f4402014-08-29 07:25:23 +00001855 }
1856 if (Args.hasArg(options::OPT_emit_llvm)) {
Shuxin Yang4b3c7ff2013-08-23 21:34:57 +00001857 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001858 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
Justin Lebar41094612016-01-11 23:07:27 +00001859 return C.MakeAction<BackendJobAction>(Input, Output);
Daniel Dunbar65229332009-03-13 11:38:42 +00001860 }
Justin Lebar41094612016-01-11 23:07:27 +00001861 return C.MakeAction<BackendJobAction>(Input, types::TY_PP_Asm);
Daniel Dunbar65229332009-03-13 11:38:42 +00001862 }
1863 case phases::Assemble:
Justin Lebar21e5d4f2016-01-14 21:41:27 +00001864 return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object);
Daniel Dunbar65229332009-03-13 11:38:42 +00001865 }
1866
David Blaikie83d382b2011-09-23 05:06:16 +00001867 llvm_unreachable("invalid phase in ConstructPhaseAction");
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001868}
1869
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001870void Driver::BuildJobs(Compilation &C) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001871 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001872
1873 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1874
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001875 // It is an error to provide a -o option if we are making multiple output
1876 // files.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001877 if (FinalOutput) {
1878 unsigned NumOutputs = 0;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00001879 for (const Action *A : C.getActions())
1880 if (A->getType() != types::TY_Nothing)
Daniel Dunbare75d8342009-03-16 06:56:51 +00001881 ++NumOutputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001882
Daniel Dunbare75d8342009-03-16 06:56:51 +00001883 if (NumOutputs > 1) {
1884 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
Craig Topper92fc2df2014-05-17 16:56:41 +00001885 FinalOutput = nullptr;
Daniel Dunbare75d8342009-03-16 06:56:51 +00001886 }
1887 }
1888
Chad Rosier35767232013-04-30 22:01:21 +00001889 // Collect the list of architectures.
1890 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001891 if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO())
1892 for (const Arg *A : C.getArgs())
Chad Rosier35767232013-04-30 22:01:21 +00001893 if (A->getOption().matches(options::OPT_arch))
1894 ArchNames.insert(A->getValue());
Chad Rosier35767232013-04-30 22:01:21 +00001895
Justin Lebarb44f6fe2016-01-14 21:41:21 +00001896 // Set of (Action, canonical ToolChain triple) pairs we've built jobs for.
1897 std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001898 for (Action *A : C.getActions()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001899 // If we are linking an image for multiple archs then the linker wants
1900 // -arch_multiple and -final_output <final image name>. Unfortunately, this
1901 // doesn't fit in cleanly because we have to pass this information down.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001902 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001903 // FIXME: This is a hack; find a cleaner way to integrate this into the
1904 // process.
Craig Topper92fc2df2014-05-17 16:56:41 +00001905 const char *LinkingOutput = nullptr;
Daniel Dunbardd765242009-03-26 16:12:09 +00001906 if (isa<LipoJobAction>(A)) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001907 if (FinalOutput)
Richard Smithbd55daf2012-11-01 04:30:05 +00001908 LinkingOutput = FinalOutput->getValue();
Daniel Dunbare75d8342009-03-16 06:56:51 +00001909 else
Hans Wennborga7707222015-01-09 17:38:53 +00001910 LinkingOutput = getDefaultImageName();
Daniel Dunbare75d8342009-03-16 06:56:51 +00001911 }
1912
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001913 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001914 /*BoundArch*/ nullptr,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001915 /*AtTopLevel*/ true,
Chad Rosier35767232013-04-30 22:01:21 +00001916 /*MultipleArchs*/ ArchNames.size() > 1,
Samuel Antaod06239d2016-07-15 23:13:27 +00001917 /*LinkingOutput*/ LinkingOutput, CachedResults,
1918 /*BuildForOffloadDevice*/ false);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001919 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001920
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001921 // If the user passed -Qunused-arguments or there were errors, don't warn
1922 // about any unused arguments.
Argyrios Kyrtzidis31448a42010-11-18 21:47:07 +00001923 if (Diags.hasErrorOccurred() ||
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001924 C.getArgs().hasArg(options::OPT_Qunused_arguments))
Daniel Dunbard175d972009-03-18 18:03:46 +00001925 return;
1926
Daniel Dunbar58399ae2009-03-29 22:24:54 +00001927 // Claim -### here.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001928 (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001929
Nico Weber47bf5052016-04-25 21:15:49 +00001930 // Claim --driver-mode, --rsp-quoting, it was handled earlier.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001931 (void)C.getArgs().hasArg(options::OPT_driver_mode);
Nico Weber47bf5052016-04-25 21:15:49 +00001932 (void)C.getArgs().hasArg(options::OPT_rsp_quoting);
Hans Wennborg70850d82013-07-18 20:29:38 +00001933
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001934 for (Arg *A : C.getArgs()) {
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001935 // FIXME: It would be nice to be able to send the argument to the
David Blaikie9c902b52011-09-25 23:23:43 +00001936 // DiagnosticsEngine, so that extra values, position, and so on could be
1937 // printed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001938 if (!A->isClaimed()) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001939 if (A->getOption().hasFlag(options::NoArgumentUnused))
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001940 continue;
1941
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001942 // Suppress the warning automatically if this is just a flag, and it is an
1943 // instance of an argument we already claimed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001944 const Option &Opt = A->getOption();
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001945 if (Opt.getKind() == Option::FlagClass) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001946 bool DuplicateClaimed = false;
1947
Sean Silva14facf32015-06-09 01:57:17 +00001948 for (const Arg *AA : C.getArgs().filtered(&Opt)) {
1949 if (AA->isClaimed()) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001950 DuplicateClaimed = true;
1951 break;
1952 }
1953 }
1954
1955 if (DuplicateClaimed)
1956 continue;
1957 }
1958
Ehsan Akhgarid8518332016-01-25 21:14:52 +00001959 // In clang-cl, don't mention unknown arguments here since they have
1960 // already been warned about.
1961 if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
1962 Diag(clang::diag::warn_drv_unused_argument)
1963 << A->getAsString(C.getArgs());
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001964 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001965 }
Daniel Dunbar95e6b192009-03-13 22:12:33 +00001966}
Samuel Antaod06239d2016-07-15 23:13:27 +00001967/// Collapse an offloading action looking for a job of the given type. The input
1968/// action is changed to the input of the collapsed sequence. If we effectively
1969/// had a collapse return the corresponding offloading action, otherwise return
1970/// null.
1971template <typename T>
1972static OffloadAction *collapseOffloadingAction(Action *&CurAction) {
1973 if (!CurAction)
1974 return nullptr;
1975 if (auto *OA = dyn_cast<OffloadAction>(CurAction)) {
1976 if (OA->hasHostDependence())
1977 if (auto *HDep = dyn_cast<T>(OA->getHostDependence())) {
1978 CurAction = HDep;
1979 return OA;
1980 }
1981 if (OA->hasSingleDeviceDependence())
1982 if (auto *DDep = dyn_cast<T>(OA->getSingleDeviceDependence())) {
1983 CurAction = DDep;
1984 return OA;
1985 }
1986 }
1987 return nullptr;
1988}
Artem Belevichf8144ab2015-08-27 18:10:41 +00001989// Returns a Tool for a given JobAction. In case the action and its
1990// predecessors can be combined, updates Inputs with the inputs of the
1991// first combined action. If one of the collapsed actions is a
1992// CudaHostAction, updates CollapsedCHA with the pointer to it so the
1993// caller can deal with extra handling such action requires.
1994static const Tool *selectToolForJob(Compilation &C, bool SaveTemps,
Steven Wu574b0f22016-03-01 01:07:58 +00001995 bool EmbedBitcode, const ToolChain *TC,
1996 const JobAction *JA,
Artem Belevichf8144ab2015-08-27 18:10:41 +00001997 const ActionList *&Inputs,
Samuel Antaod06239d2016-07-15 23:13:27 +00001998 ActionList &CollapsedOffloadAction) {
Craig Topper92fc2df2014-05-17 16:56:41 +00001999 const Tool *ToolForJob = nullptr;
Samuel Antaod06239d2016-07-15 23:13:27 +00002000 CollapsedOffloadAction.clear();
Daniel Dunbarc4343942010-02-03 03:07:56 +00002001
2002 // See if we should look for a compiler with an integrated assembler. We match
2003 // bottom up, so what we are actually looking for is an assembler job with a
Reid Klecknerda0acc82014-12-18 23:07:04 +00002004 // compiler input.
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00002005
Samuel Antaod06239d2016-07-15 23:13:27 +00002006 // Look through offload actions between assembler and backend actions.
2007 Action *BackendJA = (isa<AssembleJobAction>(JA) && Inputs->size() == 1)
2008 ? *Inputs->begin()
2009 : nullptr;
2010 auto *BackendOA = collapseOffloadingAction<BackendJobAction>(BackendJA);
2011
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002012 if (TC->useIntegratedAs() && !SaveTemps &&
David Peixotto3e325d72013-12-06 20:27:33 +00002013 !C.getArgs().hasArg(options::OPT_via_file_asm) &&
Hans Wennborg2c21f742013-10-17 16:16:23 +00002014 !C.getArgs().hasArg(options::OPT__SLASH_FA) &&
Samuel Antaod06239d2016-07-15 23:13:27 +00002015 !C.getArgs().hasArg(options::OPT__SLASH_Fa) && BackendJA &&
2016 isa<BackendJobAction>(BackendJA)) {
Steven Wu574b0f22016-03-01 01:07:58 +00002017 // A BackendJob is always preceded by a CompileJob, and without -save-temps
2018 // or -fembed-bitcode, they will always get combined together, so instead of
2019 // checking the backend tool, check if the tool for the CompileJob has an
2020 // integrated assembler. For -fembed-bitcode, CompileJob is still used to
2021 // look up tools for BackendJob, but they need to match before we can split
2022 // them.
Samuel Antaod06239d2016-07-15 23:13:27 +00002023
2024 // Look through offload actions between backend and compile actions.
2025 Action *CompileJA = *BackendJA->getInputs().begin();
2026 auto *CompileOA = collapseOffloadingAction<CompileJobAction>(CompileJA);
2027
2028 assert(CompileJA && isa<CompileJobAction>(CompileJA) &&
2029 "Backend job is not preceeded by compile job.");
2030 const Tool *Compiler = TC->SelectTool(*cast<CompileJobAction>(CompileJA));
Rafael Espindola79764462013-03-24 15:06:53 +00002031 if (!Compiler)
Craig Topper92fc2df2014-05-17 16:56:41 +00002032 return nullptr;
Steven Wu574b0f22016-03-01 01:07:58 +00002033 // When using -fembed-bitcode, it is required to have the same tool (clang)
2034 // for both CompilerJA and BackendJA. Otherwise, combine two stages.
2035 if (EmbedBitcode) {
2036 JobAction *InputJA = cast<JobAction>(*Inputs->begin());
2037 const Tool *BackendTool = TC->SelectTool(*InputJA);
2038 if (BackendTool == Compiler)
2039 CompileJA = InputJA;
2040 }
Rafael Espindola79764462013-03-24 15:06:53 +00002041 if (Compiler->hasIntegratedAssembler()) {
Artem Belevichf8144ab2015-08-27 18:10:41 +00002042 Inputs = &CompileJA->getInputs();
Bob Wilson23a55f12014-12-21 07:00:00 +00002043 ToolForJob = Compiler;
Samuel Antaod06239d2016-07-15 23:13:27 +00002044 // Save the collapsed offload actions because they may still contain
2045 // device actions.
2046 if (CompileOA)
2047 CollapsedOffloadAction.push_back(CompileOA);
2048 if (BackendOA)
2049 CollapsedOffloadAction.push_back(BackendOA);
Bob Wilson23a55f12014-12-21 07:00:00 +00002050 }
2051 }
2052
2053 // A backend job should always be combined with the preceding compile job
Steven Wu574b0f22016-03-01 01:07:58 +00002054 // unless OPT_save_temps or OPT_fembed_bitcode is enabled and the compiler is
2055 // capable of emitting LLVM IR as an intermediate output.
Bob Wilson23a55f12014-12-21 07:00:00 +00002056 if (isa<BackendJobAction>(JA)) {
2057 // Check if the compiler supports emitting LLVM IR.
2058 assert(Inputs->size() == 1);
Samuel Antaod06239d2016-07-15 23:13:27 +00002059
2060 // Look through offload actions between backend and compile actions.
2061 Action *CompileJA = *JA->getInputs().begin();
2062 auto *CompileOA = collapseOffloadingAction<CompileJobAction>(CompileJA);
2063
2064 assert(CompileJA && isa<CompileJobAction>(CompileJA) &&
2065 "Backend job is not preceeded by compile job.");
2066 const Tool *Compiler = TC->SelectTool(*cast<CompileJobAction>(CompileJA));
Bob Wilson23a55f12014-12-21 07:00:00 +00002067 if (!Compiler)
2068 return nullptr;
Steven Wu574b0f22016-03-01 01:07:58 +00002069 if (!Compiler->canEmitIR() ||
2070 (!SaveTemps && !EmbedBitcode)) {
Artem Belevichf8144ab2015-08-27 18:10:41 +00002071 Inputs = &CompileJA->getInputs();
Rafael Espindola79764462013-03-24 15:06:53 +00002072 ToolForJob = Compiler;
Samuel Antaod06239d2016-07-15 23:13:27 +00002073
2074 if (CompileOA)
2075 CollapsedOffloadAction.push_back(CompileOA);
Daniel Dunbarc4343942010-02-03 03:07:56 +00002076 }
2077 }
2078
2079 // Otherwise use the tool for the current job.
2080 if (!ToolForJob)
Rafael Espindola79764462013-03-24 15:06:53 +00002081 ToolForJob = TC->SelectTool(*JA);
Daniel Dunbarc4343942010-02-03 03:07:56 +00002082
2083 // See if we should use an integrated preprocessor. We do so when we have
2084 // exactly one input, since this is the only use case we care about
2085 // (irrelevant since we don't support combine yet).
Samuel Antaod06239d2016-07-15 23:13:27 +00002086
2087 // Look through offload actions after preprocessing.
2088 Action *PreprocessJA = (Inputs->size() == 1) ? *Inputs->begin() : nullptr;
2089 auto *PreprocessOA =
2090 collapseOffloadingAction<PreprocessJobAction>(PreprocessJA);
2091
2092 if (PreprocessJA && isa<PreprocessJobAction>(PreprocessJA) &&
Daniel Dunbarc4343942010-02-03 03:07:56 +00002093 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002094 !C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00002095 !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
Samuel Antaod06239d2016-07-15 23:13:27 +00002096 ToolForJob->hasIntegratedCPP()) {
2097 Inputs = &PreprocessJA->getInputs();
2098 if (PreprocessOA)
2099 CollapsedOffloadAction.push_back(PreprocessOA);
2100 }
Daniel Dunbarc4343942010-02-03 03:07:56 +00002101
Rafael Espindola79764462013-03-24 15:06:53 +00002102 return ToolForJob;
Daniel Dunbarc4343942010-02-03 03:07:56 +00002103}
2104
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002105InputInfo Driver::BuildJobsForAction(
2106 Compilation &C, const Action *A, const ToolChain *TC, const char *BoundArch,
2107 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
Samuel Antaod06239d2016-07-15 23:13:27 +00002108 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
2109 bool BuildForOffloadDevice) const {
Justin Lebar55c83322016-01-16 03:30:08 +00002110 // The bound arch is not necessarily represented in the toolchain's triple --
2111 // for example, armv7 and armv7s both map to the same triple -- so we need
2112 // both in our map.
2113 std::string TriplePlusArch = TC->getTriple().normalize();
2114 if (BoundArch) {
2115 TriplePlusArch += "-";
2116 TriplePlusArch += BoundArch;
2117 }
2118 std::pair<const Action *, std::string> ActionTC = {A, TriplePlusArch};
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002119 auto CachedResult = CachedResults.find(ActionTC);
2120 if (CachedResult != CachedResults.end()) {
2121 return CachedResult->second;
2122 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002123 InputInfo Result = BuildJobsForActionNoCache(
2124 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
2125 CachedResults, BuildForOffloadDevice);
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002126 CachedResults[ActionTC] = Result;
2127 return Result;
2128}
2129
2130InputInfo Driver::BuildJobsForActionNoCache(
2131 Compilation &C, const Action *A, const ToolChain *TC, const char *BoundArch,
2132 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
Samuel Antaod06239d2016-07-15 23:13:27 +00002133 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
2134 bool BuildForOffloadDevice) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002135 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbarc4acf9d2009-03-18 23:18:19 +00002136
Samuel Antaod06239d2016-07-15 23:13:27 +00002137 InputInfoList OffloadDependencesInputInfo;
2138 if (const OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
2139 // The offload action is expected to be used in four different situations.
2140 //
2141 // a) Set a toolchain/architecture/kind for a host action:
2142 // Host Action 1 -> OffloadAction -> Host Action 2
2143 //
2144 // b) Set a toolchain/architecture/kind for a device action;
2145 // Device Action 1 -> OffloadAction -> Device Action 2
2146 //
2147 // c) Specify a device dependences to a host action;
2148 // Device Action 1 _
2149 // \
2150 // Host Action 1 ---> OffloadAction -> Host Action 2
2151 //
2152 // d) Specify a host dependence to a device action.
2153 // Host Action 1 _
2154 // \
2155 // Device Action 1 ---> OffloadAction -> Device Action 2
2156 //
2157 // For a) and b), we just return the job generated for the dependence. For
2158 // c) and d) we override the current action with the host/device dependence
2159 // if the current toolchain is host/device and set the offload dependences
2160 // info with the jobs obtained from the device/host dependence(s).
2161
2162 // If there is a single device option, just generate the job for it.
2163 if (OA->hasSingleDeviceDependence()) {
2164 InputInfo DevA;
2165 OA->doOnEachDeviceDependence([&](Action *DepA, const ToolChain *DepTC,
2166 const char *DepBoundArch) {
2167 DevA =
2168 BuildJobsForAction(C, DepA, DepTC, DepBoundArch, AtTopLevel,
2169 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput,
2170 CachedResults, /*BuildForOffloadDevice=*/true);
2171 });
2172 return DevA;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002173 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002174
2175 // If 'Action 2' is host, we generate jobs for the device dependences and
2176 // override the current action with the host dependence. Otherwise, we
2177 // generate the host dependences and override the action with the device
2178 // dependence. The dependences can't therefore be a top-level action.
2179 OA->doOnEachDependence(
2180 /*IsHostDependence=*/BuildForOffloadDevice,
2181 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
2182 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
2183 C, DepA, DepTC, DepBoundArch, /*AtTopLevel=*/false,
2184 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput, CachedResults,
2185 /*BuildForOffloadDevice=*/DepA->getOffloadingDeviceKind() !=
2186 Action::OFK_None));
2187 });
2188
2189 A = BuildForOffloadDevice
2190 ? OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)
2191 : OA->getHostDependence();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002192 }
2193
Daniel Dunbare75d8342009-03-16 06:56:51 +00002194 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002195 // FIXME: It would be nice to not claim this here; maybe the old scheme of
2196 // just using Args was better?
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00002197 const Arg &Input = IA->getInputArg();
2198 Input.claim();
Daniel Dunbar35cbfeb2010-06-09 22:31:08 +00002199 if (Input.getOption().matches(options::OPT_INPUT)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00002200 const char *Name = Input.getValue();
Justin Lebard98cea82016-01-11 23:15:21 +00002201 return InputInfo(A, Name, /* BaseInput = */ Name);
Douglas Katzman678d0cb2015-06-16 18:01:24 +00002202 }
Justin Lebard98cea82016-01-11 23:15:21 +00002203 return InputInfo(A, &Input, /* BaseInput = */ "");
Daniel Dunbare75d8342009-03-16 06:56:51 +00002204 }
2205
2206 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
Chad Rosiera78a6eb2012-04-27 16:50:38 +00002207 const ToolChain *TC;
Chad Rosier631fa102012-04-27 16:48:16 +00002208 const char *ArchName = BAA->getArchName();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00002209
Chad Rosier631fa102012-04-27 16:48:16 +00002210 if (ArchName)
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +00002211 TC = &getToolChain(C.getArgs(),
2212 computeTargetTriple(*this, DefaultTargetTriple,
2213 C.getArgs(), ArchName));
Chad Rosiera78a6eb2012-04-27 16:50:38 +00002214 else
2215 TC = &C.getDefaultToolChain();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00002216
Nico Weber5a459f82016-02-23 19:30:43 +00002217 return BuildJobsForAction(C, *BAA->input_begin(), TC, ArchName, AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00002218 MultipleArchs, LinkingOutput, CachedResults,
2219 BuildForOffloadDevice);
Daniel Dunbare75d8342009-03-16 06:56:51 +00002220 }
2221
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002222
Daniel Dunbare75d8342009-03-16 06:56:51 +00002223 const ActionList *Inputs = &A->getInputs();
Daniel Dunbarc4343942010-02-03 03:07:56 +00002224
2225 const JobAction *JA = cast<JobAction>(A);
Samuel Antaod06239d2016-07-15 23:13:27 +00002226 ActionList CollapsedOffloadActions;
2227
Artem Belevichf8144ab2015-08-27 18:10:41 +00002228 const Tool *T =
Steven Wu574b0f22016-03-01 01:07:58 +00002229 selectToolForJob(C, isSaveTempsEnabled(), embedBitcodeEnabled(), TC, JA,
Samuel Antaod06239d2016-07-15 23:13:27 +00002230 Inputs, CollapsedOffloadActions);
Rafael Espindola79764462013-03-24 15:06:53 +00002231 if (!T)
Justin Lebar9eaa4892016-01-11 23:09:32 +00002232 return InputInfo();
Daniel Dunbare75d8342009-03-16 06:56:51 +00002233
Samuel Antaod06239d2016-07-15 23:13:27 +00002234 // If we've collapsed action list that contained OffloadAction we
2235 // need to build jobs for host/device-side inputs it may have held.
2236 for (const auto *OA : CollapsedOffloadActions)
2237 cast<OffloadAction>(OA)->doOnEachDependence(
2238 /*IsHostDependence=*/BuildForOffloadDevice,
2239 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
2240 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
Artem Belevichbee2f412016-08-22 18:50:34 +00002241 C, DepA, DepTC, DepBoundArch, /* AtTopLevel */ false,
Samuel Antaod06239d2016-07-15 23:13:27 +00002242 /*MultipleArchs=*/!!DepBoundArch, LinkingOutput, CachedResults,
2243 /*BuildForOffloadDevice=*/DepA->getOffloadingDeviceKind() !=
2244 Action::OFK_None));
2245 });
Artem Belevichf8144ab2015-08-27 18:10:41 +00002246
Daniel Dunbare75d8342009-03-16 06:56:51 +00002247 // Only use pipes when there is exactly one input.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00002248 InputInfoList InputInfos;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00002249 for (const Action *Input : *Inputs) {
Eric Christopher14668dd2013-02-18 00:38:25 +00002250 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
2251 // shouldn't get temporary output names.
Daniel Dunbar6beaf512010-06-04 18:28:41 +00002252 // FIXME: Clean this up.
Justin Lebar9eaa4892016-01-11 23:09:32 +00002253 bool SubJobAtTopLevel =
2254 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
Samuel Antaod06239d2016-07-15 23:13:27 +00002255 InputInfos.push_back(BuildJobsForAction(
2256 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
2257 CachedResults, BuildForOffloadDevice));
Daniel Dunbare75d8342009-03-16 06:56:51 +00002258 }
2259
Daniel Dunbare75d8342009-03-16 06:56:51 +00002260 // Always use the first input as the base input.
2261 const char *BaseInput = InputInfos[0].getBaseInput();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002262
Daniel Dunbar6beaf512010-06-04 18:28:41 +00002263 // ... except dsymutil actions, which use their actual input as the base
2264 // input.
2265 if (JA->getType() == types::TY_dSYM)
2266 BaseInput = InputInfos[0].getFilename();
2267
Samuel Antaod06239d2016-07-15 23:13:27 +00002268 // Append outputs of offload device jobs to the input list
2269 if (!OffloadDependencesInputInfo.empty())
2270 InputInfos.append(OffloadDependencesInputInfo.begin(),
2271 OffloadDependencesInputInfo.end());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002272
Vedant Kumar18286cf2016-07-27 23:02:20 +00002273 // Set the effective triple of the toolchain for the duration of this job.
2274 llvm::Triple EffectiveTriple;
2275 const ToolChain &ToolTC = T->getToolChain();
2276 const ArgList &Args = C.getArgsForToolChain(TC, BoundArch);
2277 if (InputInfos.size() != 1) {
2278 EffectiveTriple = llvm::Triple(ToolTC.ComputeEffectiveClangTriple(Args));
2279 } else {
2280 // Pass along the input type if it can be unambiguously determined.
2281 EffectiveTriple = llvm::Triple(
2282 ToolTC.ComputeEffectiveClangTriple(Args, InputInfos[0].getType()));
2283 }
2284 RegisterEffectiveTriple TripleRAII(ToolTC, EffectiveTriple);
2285
Daniel Dunbard00272f2010-08-02 02:38:15 +00002286 // Determine the place to write output to, if any.
Justin Lebar9eaa4892016-01-11 23:09:32 +00002287 InputInfo Result;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002288 if (JA->getType() == types::TY_Nothing)
Justin Lebard98cea82016-01-11 23:15:21 +00002289 Result = InputInfo(A, BaseInput);
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00002290 else
Justin Lebard98cea82016-01-11 23:15:21 +00002291 Result = InputInfo(A, GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
Samuel Antaod06239d2016-07-15 23:13:27 +00002292 AtTopLevel, MultipleArchs,
2293 TC->getTriple().normalize()),
Justin Lebard98cea82016-01-11 23:15:21 +00002294 BaseInput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002295
Chad Rosierbe10f982011-08-02 17:58:04 +00002296 if (CCCPrintBindings && !CCGenDiagnostics) {
Rafael Espindola79764462013-03-24 15:06:53 +00002297 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
2298 << " - \"" << T->getName() << "\", inputs: [";
Daniel Dunbarb39cc522009-03-17 22:47:06 +00002299 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
2300 llvm::errs() << InputInfos[i].getAsString();
2301 if (i + 1 != e)
2302 llvm::errs() << ", ";
2303 }
2304 llvm::errs() << "], output: " << Result.getAsString() << "\n";
2305 } else {
Vedant Kumar5fb00e42016-07-27 23:01:55 +00002306 T->ConstructJob(C, *JA, Result, InputInfos,
Rafael Espindola79764462013-03-24 15:06:53 +00002307 C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
Daniel Dunbarb39cc522009-03-17 22:47:06 +00002308 }
Justin Lebar9eaa4892016-01-11 23:09:32 +00002309 return Result;
Daniel Dunbare75d8342009-03-16 06:56:51 +00002310}
2311
Hans Wennborga7707222015-01-09 17:38:53 +00002312const char *Driver::getDefaultImageName() const {
2313 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
2314 return Target.isOSWindows() ? "a.exe" : "a.out";
2315}
2316
Hans Wennborg2c21f742013-10-17 16:16:23 +00002317/// \brief Create output filename based on ArgValue, which could either be a
2318/// full filename, filename without extension, or a directory. If ArgValue
2319/// does not provide a filename, then use BaseName, and use the extension
2320/// suitable for FileType.
Hans Wennborg207fcf02013-08-12 21:56:42 +00002321static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002322 StringRef BaseName,
2323 types::ID FileType) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002324 SmallString<128> Filename = ArgValue;
Justin Bogner5aaf2e72014-06-26 20:59:36 +00002325
Hans Wennborgf1a74252013-09-10 20:18:04 +00002326 if (ArgValue.empty()) {
2327 // If the argument is empty, output to BaseName in the current dir.
2328 Filename = BaseName;
2329 } else if (llvm::sys::path::is_separator(Filename.back())) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002330 // If the argument is a directory, output to BaseName in that dir.
2331 llvm::sys::path::append(Filename, BaseName);
2332 }
2333
2334 if (!llvm::sys::path::has_extension(ArgValue)) {
2335 // If the argument didn't provide an extension, then set it.
2336 const char *Extension = types::getTypeTempSuffix(FileType, true);
Hans Wennborgf1a74252013-09-10 20:18:04 +00002337
2338 if (FileType == types::TY_Image &&
2339 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
2340 // The output file is a dll.
2341 Extension = "dll";
2342 }
2343
Hans Wennborg207fcf02013-08-12 21:56:42 +00002344 llvm::sys::path::replace_extension(Filename, Extension);
2345 }
2346
2347 return Args.MakeArgString(Filename.c_str());
2348}
2349
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002350const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002351 const char *BaseInput,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002352 const char *BoundArch, bool AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00002353 bool MultipleArchs,
2354 StringRef NormalizedTriple) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00002355 llvm::PrettyStackTraceString CrashInfo("Computing output path");
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002356 // Output to a user requested destination?
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002357 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002358 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
Chad Rosier633dcdc2013-01-24 19:14:47 +00002359 return C.addResultFile(FinalOutput->getValue(), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002360 }
2361
Hans Wennborge0053472013-12-20 18:40:46 +00002362 // For /P, preprocess to file named after BaseInput.
2363 if (C.getArgs().hasArg(options::OPT__SLASH_P)) {
2364 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
2365 StringRef BaseName = llvm::sys::path::filename(BaseInput);
Hans Wennborg04c764f2014-06-17 00:19:12 +00002366 StringRef NameArg;
Greg Bedwell065f70a2015-06-09 10:24:06 +00002367 if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi))
Hans Wennborg04c764f2014-06-17 00:19:12 +00002368 NameArg = A->getValue();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002369 return C.addResultFile(
2370 MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, types::TY_PP_C),
2371 &JA);
Hans Wennborge0053472013-12-20 18:40:46 +00002372 }
2373
Nick Lewycky6e1ce292010-09-24 00:46:53 +00002374 // Default to writing to stdout?
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00002375 if (AtTopLevel && !CCGenDiagnostics &&
2376 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
Nick Lewycky6e1ce292010-09-24 00:46:53 +00002377 return "-";
2378
Hans Wennborg2c21f742013-10-17 16:16:23 +00002379 // Is this the assembly listing for /FA?
2380 if (JA.getType() == types::TY_PP_Asm &&
2381 (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
2382 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
2383 // Use /Fa and the input filename to determine the asm file name.
2384 StringRef BaseName = llvm::sys::path::filename(BaseInput);
2385 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002386 return C.addResultFile(
2387 MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, JA.getType()),
2388 &JA);
Hans Wennborg2c21f742013-10-17 16:16:23 +00002389 }
2390
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002391 // Output to a temporary file?
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002392 if ((!AtTopLevel && !isSaveTempsEnabled() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002393 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
Chad Rosierbe10f982011-08-02 17:58:04 +00002394 CCGenDiagnostics) {
Chad Rosier97c37372011-08-26 22:27:02 +00002395 StringRef Name = llvm::sys::path::filename(BaseInput);
2396 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002397 std::string TmpName = GetTemporaryPath(
2398 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002399 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002400 }
2401
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00002402 SmallString<128> BasePath(BaseInput);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00002403 StringRef BaseName;
Daniel Dunbar67fea712011-03-25 18:16:51 +00002404
2405 // Dsymutil actions should use the full path.
Eric Christopher551ef452011-08-23 17:56:55 +00002406 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
Daniel Dunbar67fea712011-03-25 18:16:51 +00002407 BaseName = BasePath;
2408 else
2409 BaseName = llvm::sys::path::filename(BasePath);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002410
2411 // Determine what the derived output name should be.
2412 const char *NamedOutput;
Hans Wennborg2b89a262013-08-06 22:11:28 +00002413
Hans Wennborg8fa96772015-06-13 02:53:50 +00002414 if (JA.getType() == types::TY_Object &&
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00002415 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
2416 // The /Fo or /o flag decides the object filename.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002417 StringRef Val =
2418 C.getArgs()
2419 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
2420 ->getValue();
2421 NamedOutput =
2422 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Object);
Hans Wennborg207fcf02013-08-12 21:56:42 +00002423 } else if (JA.getType() == types::TY_Image &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002424 C.getArgs().hasArg(options::OPT__SLASH_Fe,
2425 options::OPT__SLASH_o)) {
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00002426 // The /Fe or /o flag names the linked file.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002427 StringRef Val =
2428 C.getArgs()
2429 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
2430 ->getValue();
2431 NamedOutput =
2432 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Image);
Hans Wennborgf1a74252013-09-10 20:18:04 +00002433 } else if (JA.getType() == types::TY_Image) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00002434 if (IsCLMode()) {
2435 // clang-cl uses BaseName for the executable name.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002436 NamedOutput =
2437 MakeCLOutputFilename(C.getArgs(), "", BaseName, types::TY_Image);
Hans Wennborg207fcf02013-08-12 21:56:42 +00002438 } else if (MultipleArchs && BoundArch) {
Hans Wennborga7707222015-01-09 17:38:53 +00002439 SmallString<128> Output(getDefaultImageName());
Samuel Antaod06239d2016-07-15 23:13:27 +00002440 Output += JA.getOffloadingFileNamePrefix(NormalizedTriple);
Chad Rosier35767232013-04-30 22:01:21 +00002441 Output += "-";
2442 Output.append(BoundArch);
2443 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
Nico Weber2ca4be92016-03-01 23:16:44 +00002444 } else {
Hans Wennborga7707222015-01-09 17:38:53 +00002445 NamedOutput = getDefaultImageName();
Nico Weber2ca4be92016-03-01 23:16:44 +00002446 }
2447 } else if (JA.getType() == types::TY_PCH && IsCLMode()) {
2448 NamedOutput = C.getArgs().MakeArgString(GetClPchPath(C, BaseName).c_str());
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002449 } else {
Hans Wennborg0a096a02013-09-05 17:05:56 +00002450 const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002451 assert(Suffix && "All types used for output should have a suffix.");
2452
2453 std::string::size_type End = std::string::npos;
2454 if (!types::appendSuffixForType(JA.getType()))
2455 End = BaseName.rfind('.');
Chad Rosier35767232013-04-30 22:01:21 +00002456 SmallString<128> Suffixed(BaseName.substr(0, End));
Samuel Antaod06239d2016-07-15 23:13:27 +00002457 Suffixed += JA.getOffloadingFileNamePrefix(NormalizedTriple);
Chad Rosier35767232013-04-30 22:01:21 +00002458 if (MultipleArchs && BoundArch) {
2459 Suffixed += "-";
2460 Suffixed.append(BoundArch);
2461 }
Bob Wilson23a55f12014-12-21 07:00:00 +00002462 // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for
2463 // the unoptimized bitcode so that it does not get overwritten by the ".bc"
2464 // optimized bitcode output.
2465 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) &&
2466 JA.getType() == types::TY_LLVM_BC)
2467 Suffixed += ".tmp";
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002468 Suffixed += '.';
2469 Suffixed += Suffix;
2470 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
2471 }
2472
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002473 // Prepend object file path if -save-temps=obj
2474 if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) &&
2475 JA.getType() != types::TY_PCH) {
2476 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
2477 SmallString<128> TempPath(FinalOutput->getValue());
2478 llvm::sys::path::remove_filename(TempPath);
2479 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
2480 llvm::sys::path::append(TempPath, OutputFileName);
2481 NamedOutput = C.getArgs().MakeArgString(TempPath.c_str());
2482 }
2483
Chad Rosier62135492012-07-09 17:31:28 +00002484 // If we're saving temps and the temp file conflicts with the input file,
Chad Rosier5b58af02012-04-20 20:05:08 +00002485 // then avoid overwriting input file.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00002486 if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) {
Chad Rosier5b58af02012-04-20 20:05:08 +00002487 bool SameFile = false;
2488 SmallString<256> Result;
2489 llvm::sys::fs::current_path(Result);
2490 llvm::sys::path::append(Result, BaseName);
2491 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
2492 // Must share the same path to conflict.
2493 if (SameFile) {
2494 StringRef Name = llvm::sys::path::filename(BaseInput);
2495 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002496 std::string TmpName = GetTemporaryPath(
2497 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Chad Rosier5b58af02012-04-20 20:05:08 +00002498 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
2499 }
Chad Rosierf8412cd2011-07-15 21:54:29 +00002500 }
2501
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002502 // As an annoying special case, PCH generation doesn't strip the pathname.
Nico Weber8ab92192016-03-02 23:29:29 +00002503 if (JA.getType() == types::TY_PCH && !IsCLMode()) {
Michael J. Spencere1696752010-12-18 00:19:12 +00002504 llvm::sys::path::remove_filename(BasePath);
2505 if (BasePath.empty())
Daniel Dunbare6c83192009-03-18 09:58:30 +00002506 BasePath = NamedOutput;
2507 else
Michael J. Spencere1696752010-12-18 00:19:12 +00002508 llvm::sys::path::append(BasePath, NamedOutput);
Chad Rosier633dcdc2013-01-24 19:14:47 +00002509 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002510 } else {
Chad Rosier633dcdc2013-01-24 19:14:47 +00002511 return C.addResultFile(NamedOutput, &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00002512 }
2513}
2514
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002515std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
Chandler Carruth84559242010-03-22 01:52:07 +00002516 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00002517 // attempting to use this prefix when looking for file paths.
Douglas Katzman26eabf62015-06-24 15:10:30 +00002518 for (const std::string &Dir : PrefixDirs) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00002519 if (Dir.empty())
2520 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00002521 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00002522 llvm::sys::path::append(P, Name);
2523 if (llvm::sys::fs::exists(Twine(P)))
Chandler Carruth84559242010-03-22 01:52:07 +00002524 return P.str();
2525 }
2526
Rafael Espindola609a6642013-06-24 18:33:43 +00002527 SmallString<128> P(ResourceDir);
2528 llvm::sys::path::append(P, Name);
2529 if (llvm::sys::fs::exists(Twine(P)))
Peter Collingbournefa9771f2011-09-06 02:08:31 +00002530 return P.str();
2531
Douglas Katzman26eabf62015-06-24 15:10:30 +00002532 for (const std::string &Dir : TC.getFilePaths()) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00002533 if (Dir.empty())
2534 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00002535 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00002536 llvm::sys::path::append(P, Name);
2537 if (llvm::sys::fs::exists(Twine(P)))
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002538 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002539 }
2540
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002541 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00002542}
2543
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002544void Driver::generatePrefixedToolNames(
2545 const char *Tool, const ToolChain &TC,
2546 SmallVectorImpl<std::string> &Names) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002547 // FIXME: Needs a better variable than DefaultTargetTriple
Chandler Carruth1256cc82016-06-11 04:57:29 +00002548 Names.emplace_back(DefaultTargetTriple + "-" + Tool);
Benjamin Kramer3204b152015-05-29 19:42:19 +00002549 Names.emplace_back(Tool);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00002550
2551 // Allow the discovery of tools prefixed with LLVM's default target triple.
2552 std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
2553 if (LLVMDefaultTargetTriple != DefaultTargetTriple)
2554 Names.emplace_back(LLVMDefaultTargetTriple + "-" + Tool);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002555}
2556
Benjamin Kramer7111b912014-11-04 20:26:01 +00002557static bool ScanDirForExecutable(SmallString<128> &Dir,
2558 ArrayRef<std::string> Names) {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002559 for (const auto &Name : Names) {
2560 llvm::sys::path::append(Dir, Name);
2561 if (llvm::sys::fs::can_execute(Twine(Dir)))
2562 return true;
2563 llvm::sys::path::remove_filename(Dir);
2564 }
2565 return false;
2566}
2567
Simon Atanasyanb16488c2012-10-03 19:52:37 +00002568std::string Driver::GetProgramPath(const char *Name,
2569 const ToolChain &TC) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002570 SmallVector<std::string, 2> TargetSpecificExecutables;
2571 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
2572
Chandler Carruth84559242010-03-22 01:52:07 +00002573 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00002574 // attempting to use this prefix when looking for program paths.
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002575 for (const auto &PrefixDir : PrefixDirs) {
2576 if (llvm::sys::fs::is_directory(PrefixDir)) {
2577 SmallString<128> P(PrefixDir);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002578 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002579 return P.str();
Simon Atanasyana47ba292012-10-31 14:39:28 +00002580 } else {
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002581 SmallString<128> P(PrefixDir + Name);
Rafael Espindola609a6642013-06-24 18:33:43 +00002582 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002583 return P.str();
Simon Atanasyan86bdab72012-10-31 12:01:53 +00002584 }
Chandler Carruth84559242010-03-22 01:52:07 +00002585 }
2586
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002587 const ToolChain::path_list &List = TC.getProgramPaths();
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00002588 for (const auto &Path : List) {
2589 SmallString<128> P(Path);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00002590 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00002591 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00002592 }
2593
Daniel Dunbar76ce7412009-03-23 16:15:50 +00002594 // If all else failed, search the path.
Michael J. Spencerb011d482014-11-07 21:30:32 +00002595 for (const auto &TargetSpecificExecutable : TargetSpecificExecutables)
2596 if (llvm::ErrorOr<std::string> P =
2597 llvm::sys::findProgramByName(TargetSpecificExecutable))
Michael J. Spencer04162ea2014-11-04 01:30:55 +00002598 return *P;
Daniel Dunbar6f668772009-03-18 21:34:08 +00002599
Daniel Dunbar1ce81532009-09-09 22:33:00 +00002600 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00002601}
2602
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002603std::string Driver::GetTemporaryPath(StringRef Prefix,
2604 const char *Suffix) const {
Rafael Espindola37d229d2013-06-25 04:26:55 +00002605 SmallString<128> Path;
Rafael Espindolac0809172014-06-12 14:02:15 +00002606 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
Rafael Espindola37d229d2013-06-25 04:26:55 +00002607 if (EC) {
2608 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002609 return "";
2610 }
2611
Rafael Espindola37d229d2013-06-25 04:26:55 +00002612 return Path.str();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00002613}
2614
Nico Weber2ca4be92016-03-01 23:16:44 +00002615std::string Driver::GetClPchPath(Compilation &C, StringRef BaseName) const {
2616 SmallString<128> Output;
2617 if (Arg *FpArg = C.getArgs().getLastArg(options::OPT__SLASH_Fp)) {
2618 // FIXME: If anybody needs it, implement this obscure rule:
2619 // "If you specify a directory without a file name, the default file name
2620 // is VCx0.pch., where x is the major version of Visual C++ in use."
2621 Output = FpArg->getValue();
2622
2623 // "If you do not specify an extension as part of the path name, an
2624 // extension of .pch is assumed. "
2625 if (!llvm::sys::path::has_extension(Output))
2626 Output += ".pch";
2627 } else {
2628 Output = BaseName;
2629 llvm::sys::path::replace_extension(Output, ".pch");
2630 }
2631 return Output.str();
2632}
2633
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002634const ToolChain &Driver::getToolChain(const ArgList &Args,
Artem Belevich959e0542015-07-10 19:47:55 +00002635 const llvm::Triple &Target) const {
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002636
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00002637 ToolChain *&TC = ToolChains[Target.str()];
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002638 if (!TC) {
2639 switch (Target.getOS()) {
Reid Kleckner330fb172016-05-11 16:19:05 +00002640 case llvm::Triple::Haiku:
2641 TC = new toolchains::Haiku(*this, Target, Args);
2642 break;
Ed Schouten3c3e58c2015-03-26 11:13:44 +00002643 case llvm::Triple::CloudABI:
2644 TC = new toolchains::CloudABI(*this, Target, Args);
2645 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002646 case llvm::Triple::Darwin:
2647 case llvm::Triple::MacOSX:
2648 case llvm::Triple::IOS:
Tim Northover6f3ff222015-10-30 16:30:27 +00002649 case llvm::Triple::TvOS:
2650 case llvm::Triple::WatchOS:
Rafael Espindola14627962013-11-24 23:28:23 +00002651 TC = new toolchains::DarwinClang(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002652 break;
2653 case llvm::Triple::DragonFly:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002654 TC = new toolchains::DragonFly(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002655 break;
2656 case llvm::Triple::OpenBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002657 TC = new toolchains::OpenBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002658 break;
Eli Friedman9fa28852012-08-08 23:57:20 +00002659 case llvm::Triple::Bitrig:
2660 TC = new toolchains::Bitrig(*this, Target, Args);
2661 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002662 case llvm::Triple::NetBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002663 TC = new toolchains::NetBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002664 break;
2665 case llvm::Triple::FreeBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002666 TC = new toolchains::FreeBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002667 break;
2668 case llvm::Triple::Minix:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002669 TC = new toolchains::Minix(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002670 break;
2671 case llvm::Triple::Linux:
Andrey Turetskiy4798eb62016-06-16 10:36:09 +00002672 case llvm::Triple::ELFIAMCU:
Chandler Carruthcf705b22012-01-25 21:03:58 +00002673 if (Target.getArch() == llvm::Triple::hexagon)
Douglas Katzman54366072015-07-27 16:53:08 +00002674 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00002675 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
2676 !Target.hasEnvironment())
2677 TC = new toolchains::MipsLLVMToolChain(*this, Target, Args);
Chandler Carruthcf705b22012-01-25 21:03:58 +00002678 else
Rafael Espindola1af7c212012-02-19 01:38:32 +00002679 TC = new toolchains::Linux(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002680 break;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002681 case llvm::Triple::NaCl:
Douglas Katzman54366072015-07-27 16:53:08 +00002682 TC = new toolchains::NaClToolChain(*this, Target, Args);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00002683 break;
David Chisnallf571cde2012-02-15 13:39:01 +00002684 case llvm::Triple::Solaris:
Rafael Espindola1af7c212012-02-19 01:38:32 +00002685 TC = new toolchains::Solaris(*this, Target, Args);
David Chisnallf571cde2012-02-15 13:39:01 +00002686 break;
Tom Stellard8fa33092015-07-18 01:49:05 +00002687 case llvm::Triple::AMDHSA:
2688 TC = new toolchains::AMDGPUToolChain(*this, Target, Args);
2689 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002690 case llvm::Triple::Win32:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002691 switch (Target.getEnvironment()) {
2692 default:
2693 if (Target.isOSBinFormatELF())
2694 TC = new toolchains::Generic_ELF(*this, Target, Args);
2695 else if (Target.isOSBinFormatMachO())
2696 TC = new toolchains::MachO(*this, Target, Args);
2697 else
2698 TC = new toolchains::Generic_GCC(*this, Target, Args);
2699 break;
2700 case llvm::Triple::GNU:
Yaron Keren1c0070c2015-07-02 04:45:27 +00002701 TC = new toolchains::MinGW(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002702 break;
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00002703 case llvm::Triple::Itanium:
2704 TC = new toolchains::CrossWindowsToolChain(*this, Target, Args);
2705 break;
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002706 case llvm::Triple::MSVC:
2707 case llvm::Triple::UnknownEnvironment:
Saleem Abdulrasool819f3912014-10-22 02:37:29 +00002708 TC = new toolchains::MSVCToolChain(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00002709 break;
2710 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002711 break;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002712 case llvm::Triple::CUDA:
2713 TC = new toolchains::CudaToolChain(*this, Target, Args);
2714 break;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00002715 case llvm::Triple::PS4:
2716 TC = new toolchains::PS4CPU(*this, Target, Args);
2717 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002718 default:
Douglas Katzman9f5e70e2015-05-26 18:01:33 +00002719 // Of these targets, Hexagon is the only one that might have
2720 // an OS of Linux, in which case it got handled above already.
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002721 switch (Target.getArch()) {
2722 case llvm::Triple::tce:
Rafael Espindola84b588b2013-03-18 18:10:27 +00002723 TC = new toolchains::TCEToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002724 break;
2725 case llvm::Triple::hexagon:
Douglas Katzman54366072015-07-27 16:53:08 +00002726 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002727 break;
Jacques Pienaard964cc22016-03-28 21:02:54 +00002728 case llvm::Triple::lanai:
2729 TC = new toolchains::LanaiToolChain(*this, Target, Args);
2730 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002731 case llvm::Triple::xcore:
Douglas Katzman54366072015-07-27 16:53:08 +00002732 TC = new toolchains::XCoreToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002733 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00002734 case llvm::Triple::wasm32:
2735 case llvm::Triple::wasm64:
2736 TC = new toolchains::WebAssembly(*this, Target, Args);
2737 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002738 default:
Douglas Katzmand6e597c2015-09-17 19:56:40 +00002739 if (Target.getVendor() == llvm::Triple::Myriad)
2740 TC = new toolchains::MyriadToolChain(*this, Target, Args);
2741 else if (Target.isOSBinFormatELF())
Douglas Katzman15a63ed2015-08-12 18:36:12 +00002742 TC = new toolchains::Generic_ELF(*this, Target, Args);
2743 else if (Target.isOSBinFormatMachO())
2744 TC = new toolchains::MachO(*this, Target, Args);
2745 else
2746 TC = new toolchains::Generic_GCC(*this, Target, Args);
2747 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00002748 }
2749 }
2750 return *TC;
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00002751}
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00002752
Rafael Espindola2f69d402013-03-18 15:33:26 +00002753bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
Douglas Katzman00249092015-06-12 15:45:21 +00002754 // Say "no" if there is not exactly one input of a type clang understands.
Nico Weber5a459f82016-02-23 19:30:43 +00002755 if (JA.size() != 1 ||
2756 !types::isAcceptedByClang((*JA.input_begin())->getType()))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002757 return false;
2758
Douglas Katzman00249092015-06-12 15:45:21 +00002759 // And say "no" if this is not a kind of action clang understands.
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002760 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
Bob Wilson23a55f12014-12-21 07:00:00 +00002761 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00002762 return false;
2763
2764 return true;
2765}
2766
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002767/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
2768/// grouped values as integers. Numbers which are not provided are set to 0.
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002769///
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002770/// \return True if the entire string was parsed (9.2), or all groups were
2771/// parsed (10.3.5extrastuff).
2772bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002773 unsigned &Minor, unsigned &Micro,
2774 bool &HadExtra) {
2775 HadExtra = false;
2776
2777 Major = Minor = Micro = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002778 if (*Str == '\0')
Bob Wilson433cb312015-04-07 01:03:35 +00002779 return false;
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002780
2781 char *End;
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002782 Major = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002783 if (*Str != '\0' && *End == '\0')
2784 return true;
2785 if (*End != '.')
2786 return false;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002787
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002788 Str = End + 1;
2789 Minor = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002790 if (*Str != '\0' && *End == '\0')
2791 return true;
2792 if (*End != '.')
2793 return false;
2794
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002795 Str = End + 1;
2796 Micro = (unsigned)strtol(Str, &End, 10);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00002797 if (*Str != '\0' && *End == '\0')
2798 return true;
2799 if (Str == End)
2800 return false;
2801 HadExtra = true;
2802 return true;
2803}
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002804
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00002805/// Parse digits from a string \p Str and fulfill \p Digits with
2806/// the parsed numbers. This method assumes that the max number of
2807/// digits to look for is equal to Digits.size().
2808///
2809/// \return True if the entire string was parsed and there are
2810/// no extra characters remaining at the end.
2811bool Driver::GetReleaseVersion(const char *Str,
2812 MutableArrayRef<unsigned> Digits) {
2813 if (*Str == '\0')
2814 return false;
2815
2816 char *End;
2817 unsigned CurDigit = 0;
2818 while (CurDigit < Digits.size()) {
2819 unsigned Digit = (unsigned)strtol(Str, &End, 10);
2820 Digits[CurDigit] = Digit;
2821 if (*Str != '\0' && *End == '\0')
2822 return true;
2823 if (*End != '.' || Str == End)
2824 return false;
2825 Str = End + 1;
2826 CurDigit++;
2827 }
2828
2829 // More digits than requested, bail out...
2830 return false;
2831}
2832
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002833std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
2834 unsigned IncludedFlagsBitmask = 0;
Rafael Espindolacc707bc2013-09-25 15:54:41 +00002835 unsigned ExcludedFlagsBitmask = options::NoDriverOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002836
2837 if (Mode == CLMode) {
Hans Wennborg19076102013-07-31 20:51:53 +00002838 // Include CL and Core options.
2839 IncludedFlagsBitmask |= options::CLOption;
2840 IncludedFlagsBitmask |= options::CoreOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00002841 } else {
2842 ExcludedFlagsBitmask |= options::CLOption;
2843 }
2844
2845 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
2846}
Benjamin Kramerab88f622014-03-25 18:02:07 +00002847
Douglas Katzmanf08fadf2015-06-04 14:40:44 +00002848bool clang::driver::isOptimizationLevelFast(const ArgList &Args) {
Benjamin Kramerab88f622014-03-25 18:02:07 +00002849 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false);
2850}