blob: bdf1c08b7304ccfcc497315d64f192edadd9cf4d [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 Antao39f9da22016-10-27 16:38:05 +0000437/// Compute the desired OpenMP runtime from the flags provided.
438Driver::OpenMPRuntimeKind Driver::getOpenMPRuntime(const ArgList &Args) const {
439 StringRef RuntimeName(CLANG_DEFAULT_OPENMP_RUNTIME);
440
441 const Arg *A = Args.getLastArg(options::OPT_fopenmp_EQ);
442 if (A)
443 RuntimeName = A->getValue();
444
445 auto RT = llvm::StringSwitch<OpenMPRuntimeKind>(RuntimeName)
446 .Case("libomp", OMPRT_OMP)
447 .Case("libgomp", OMPRT_GOMP)
448 .Case("libiomp5", OMPRT_IOMP5)
449 .Default(OMPRT_Unknown);
450
451 if (RT == OMPRT_Unknown) {
452 if (A)
453 Diag(diag::err_drv_unsupported_option_argument)
454 << A->getOption().getName() << A->getValue();
455 else
456 // FIXME: We could use a nicer diagnostic here.
457 Diag(diag::err_drv_unsupported_opt) << "-fopenmp";
458 }
459
460 return RT;
461}
462
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000463void Driver::CreateOffloadingDeviceToolChains(Compilation &C,
464 InputList &Inputs) {
465
466 //
467 // CUDA
468 //
469 // We need to generate a CUDA toolchain if any of the inputs has a CUDA type.
470 if (llvm::any_of(Inputs, [](std::pair<types::ID, const llvm::opt::Arg *> &I) {
471 return types::isCuda(I.first);
472 })) {
473 const ToolChain &TC = getToolChain(
474 C.getInputArgs(),
Samuel Antaod06239d2016-07-15 23:13:27 +0000475 llvm::Triple(C.getSingleOffloadToolChain<Action::OFK_Host>()
476 ->getTriple()
477 .isArch64Bit()
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000478 ? "nvptx64-nvidia-cuda"
479 : "nvptx-nvidia-cuda"));
480 C.addOffloadDeviceToolChain(&TC, Action::OFK_Cuda);
481 }
482
483 //
Samuel Antao39f9da22016-10-27 16:38:05 +0000484 // OpenMP
485 //
486 // We need to generate an OpenMP toolchain if the user specified targets with
487 // the -fopenmp-targets option.
488 if (Arg *OpenMPTargets =
489 C.getInputArgs().getLastArg(options::OPT_fopenmp_targets_EQ)) {
490 if (OpenMPTargets->getNumValues()) {
491 // We expect that -fopenmp-targets is always used in conjunction with the
492 // option -fopenmp specifying a valid runtime with offloading support,
493 // i.e. libomp or libiomp.
494 bool HasValidOpenMPRuntime = C.getInputArgs().hasFlag(
495 options::OPT_fopenmp, options::OPT_fopenmp_EQ,
496 options::OPT_fno_openmp, false);
497 if (HasValidOpenMPRuntime) {
498 OpenMPRuntimeKind OpenMPKind = getOpenMPRuntime(C.getInputArgs());
499 HasValidOpenMPRuntime =
500 OpenMPKind == OMPRT_OMP || OpenMPKind == OMPRT_IOMP5;
501 }
502
503 if (HasValidOpenMPRuntime) {
504 llvm::StringMap<const char *> FoundNormalizedTriples;
505 for (const char *Val : OpenMPTargets->getValues()) {
506 llvm::Triple TT(Val);
507 std::string NormalizedName = TT.normalize();
508
509 // Make sure we don't have a duplicate triple.
510 auto Duplicate = FoundNormalizedTriples.find(NormalizedName);
511 if (Duplicate != FoundNormalizedTriples.end()) {
512 Diag(clang::diag::warn_drv_omp_offload_target_duplicate)
513 << Val << Duplicate->second;
514 continue;
515 }
516
517 // Store the current triple so that we can check for duplicates in the
518 // following iterations.
519 FoundNormalizedTriples[NormalizedName] = Val;
520
521 // If the specified target is invalid, emit a diagnostic.
522 if (TT.getArch() == llvm::Triple::UnknownArch)
523 Diag(clang::diag::err_drv_invalid_omp_target) << Val;
524 else {
525 const ToolChain &TC = getToolChain(C.getInputArgs(), TT);
526 C.addOffloadDeviceToolChain(&TC, Action::OFK_OpenMP);
527 }
528 }
529 } else
530 Diag(clang::diag::err_drv_expecting_fopenmp_with_fopenmp_targets);
531 } else
532 Diag(clang::diag::warn_drv_empty_joined_argument)
533 << OpenMPTargets->getAsString(C.getInputArgs());
534 }
535
536 //
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000537 // TODO: Add support for other offloading programming models here.
538 //
539
540 return;
541}
542
Chris Lattner54b16772011-07-23 17:14:25 +0000543Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000544 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
545
Eric Christopherf901e852011-08-17 22:59:59 +0000546 // FIXME: Handle environment options which affect driver behavior, somewhere
Bill Wendlingadbeb9f2012-03-12 21:24:57 +0000547 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
Chad Rosier82301162011-09-14 00:47:55 +0000548
David Majnemer85c25b42016-07-24 17:44:03 +0000549 if (Optional<std::string> CompilerPathValue =
550 llvm::sys::Process::GetEnv("COMPILER_PATH")) {
551 StringRef CompilerPath = *CompilerPathValue;
Chad Rosier82301162011-09-14 00:47:55 +0000552 while (!CompilerPath.empty()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000553 std::pair<StringRef, StringRef> Split =
554 CompilerPath.split(llvm::sys::EnvPathSeparator);
Chad Rosier82301162011-09-14 00:47:55 +0000555 PrefixDirs.push_back(Split.first);
556 CompilerPath = Split.second;
557 }
558 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000559
Hans Wennborg70850d82013-07-18 20:29:38 +0000560 // We look for the driver mode option early, because the mode can affect
561 // how other options are parsed.
Zachary Turneraff19c32016-08-12 17:47:52 +0000562 ParseDriverMode(ClangExecutable, ArgList.slice(1));
Hans Wennborg70850d82013-07-18 20:29:38 +0000563
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000564 // FIXME: What are we going to do with -V and -b?
565
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000566 // FIXME: This stuff needs to go into the Compilation, not the driver.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000567 bool CCCPrintPhases;
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000568
David Blaikie69a1d8c2015-06-22 22:07:27 +0000569 InputArgList Args = ParseArgStrings(ArgList.slice(1));
Daniel Dunbaracd69572009-12-04 21:55:23 +0000570
Filipe Cabecinhas136f35e2015-07-18 06:35:24 +0000571 // Silence driver warnings if requested
572 Diags.setIgnoreAllWarnings(Args.hasArg(options::OPT_w));
573
Rafael Espindola59ae7992009-12-07 18:28:29 +0000574 // -no-canonical-prefixes is used very early in main.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000575 Args.ClaimAllArgs(options::OPT_no_canonical_prefixes);
Rafael Espindola59ae7992009-12-07 18:28:29 +0000576
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000577 // Ignore -pipe.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000578 Args.ClaimAllArgs(options::OPT_pipe);
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000579
Daniel Dunbaracd69572009-12-04 21:55:23 +0000580 // Extract -ccc args.
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000581 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000582 // FIXME: We need to figure out where this behavior should live. Most of it
583 // should be outside in the client; the parts that aren't should have proper
584 // options, either by introducing new ones or by overloading gcc ones like -V
585 // or -b.
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000586 CCCPrintPhases = Args.hasArg(options::OPT_ccc_print_phases);
David Blaikie69a1d8c2015-06-22 22:07:27 +0000587 CCCPrintBindings = Args.hasArg(options::OPT_ccc_print_bindings);
588 if (const Arg *A = Args.getLastArg(options::OPT_ccc_gcc_name))
Richard Smithbd55daf2012-11-01 04:30:05 +0000589 CCCGenericGCCName = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000590 CCCUsePCH =
591 Args.hasFlag(options::OPT_ccc_pch_is_pch, options::OPT_ccc_pch_is_pth);
Joerg Sonnenberger17d75512012-02-22 19:15:16 +0000592 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
593 // and getToolChain is const.
Hans Wennborg2e274592013-08-13 23:38:57 +0000594 if (IsCLMode()) {
Hans Wennborg73609a02014-03-28 01:19:04 +0000595 // clang-cl targets MSVC-style Win32.
Hans Wennborg2e274592013-08-13 23:38:57 +0000596 llvm::Triple T(DefaultTargetTriple);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000597 T.setOS(llvm::Triple::Win32);
Hans Wennborg0f0e8d62015-09-18 17:11:50 +0000598 T.setVendor(llvm::Triple::PC);
Hans Wennborg9d9ce7a2014-03-28 20:49:28 +0000599 T.setEnvironment(llvm::Triple::MSVC);
Hans Wennborg2e274592013-08-13 23:38:57 +0000600 DefaultTargetTriple = T.str();
601 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000602 if (const Arg *A = Args.getLastArg(options::OPT_target))
Richard Smithbd55daf2012-11-01 04:30:05 +0000603 DefaultTargetTriple = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000604 if (const Arg *A = Args.getLastArg(options::OPT_ccc_install_dir))
Richard Smithbd55daf2012-11-01 04:30:05 +0000605 Dir = InstalledDir = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000606 for (const Arg *A : Args.filtered(options::OPT_B)) {
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000607 A->claim();
Richard Smithbd55daf2012-11-01 04:30:05 +0000608 PrefixDirs.push_back(A->getValue(0));
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000609 }
David Blaikie69a1d8c2015-06-22 22:07:27 +0000610 if (const Arg *A = Args.getLastArg(options::OPT__sysroot_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000611 SysRoot = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000612 if (const Arg *A = Args.getLastArg(options::OPT__dyld_prefix_EQ))
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +0000613 DyldPrefix = A->getValue();
David Blaikie69a1d8c2015-06-22 22:07:27 +0000614 if (Args.hasArg(options::OPT_nostdlib))
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +0000615 UseStdLib = false;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000616
David Blaikie69a1d8c2015-06-22 22:07:27 +0000617 if (const Arg *A = Args.getLastArg(options::OPT_resource_dir))
Bob Wilsona20a1da2013-03-23 05:17:59 +0000618 ResourceDir = A->getValue();
Jim Grosbach061dabf2013-03-12 20:17:58 +0000619
David Blaikie69a1d8c2015-06-22 22:07:27 +0000620 if (const Arg *A = Args.getLastArg(options::OPT_save_temps_EQ)) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000621 SaveTemps = llvm::StringSwitch<SaveTempsMode>(A->getValue())
622 .Case("cwd", SaveTempsCwd)
623 .Case("obj", SaveTempsObj)
624 .Default(SaveTempsCwd);
625 }
626
Steven Wu1257cd82016-05-18 17:04:52 +0000627 setLTOMode(Args);
628
Steven Wu844ab6a2016-11-16 06:06:44 +0000629 // Process -fembed-bitcode= flags.
630 if (Arg *A = Args.getLastArg(options::OPT_fembed_bitcode_EQ)) {
631 StringRef Name = A->getValue();
632 unsigned Model = llvm::StringSwitch<unsigned>(Name)
633 .Case("off", EmbedNone)
634 .Case("all", EmbedBitcode)
635 .Case("bitcode", EmbedBitcode)
636 .Case("marker", EmbedMarker)
637 .Default(~0U);
638 if (Model == ~0U) {
639 Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args)
640 << Name;
641 } else
642 BitcodeEmbed = static_cast<BitcodeEmbedMode>(Model);
Steven Wu574b0f22016-03-01 01:07:58 +0000643 }
644
David Blaikie69a1d8c2015-06-22 22:07:27 +0000645 std::unique_ptr<llvm::opt::InputArgList> UArgs =
646 llvm::make_unique<InputArgList>(std::move(Args));
647
Daniel Dunbar775d4062010-06-11 22:00:26 +0000648 // Perform the default argument translations.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000649 DerivedArgList *TranslatedArgs = TranslateInputArgs(*UArgs);
Daniel Dunbar775d4062010-06-11 22:00:26 +0000650
Chandler Carruthcb916192012-01-25 08:49:21 +0000651 // Owned by the host.
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +0000652 const ToolChain &TC = getToolChain(
653 *UArgs, computeTargetTriple(*this, DefaultTargetTriple, *UArgs));
Chandler Carruthcb916192012-01-25 08:49:21 +0000654
Daniel Dunbar3ce436d2009-03-16 06:42:30 +0000655 // The compilation takes ownership of Args.
David Blaikie69a1d8c2015-06-22 22:07:27 +0000656 Compilation *C = new Compilation(*this, TC, UArgs.release(), TranslatedArgs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000657
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000658 if (!HandleImmediateArgs(*C))
659 return C;
660
Chad Rosierecdede82011-08-12 22:08:57 +0000661 // Construct the list of inputs.
662 InputList Inputs;
Hans Wennborged1d0722013-08-13 21:32:29 +0000663 BuildInputs(C->getDefaultToolChain(), *TranslatedArgs, Inputs);
Chad Rosierecdede82011-08-12 22:08:57 +0000664
Samuel Antaoc1ffba52016-06-13 18:10:57 +0000665 // Populate the tool chains for the offloading devices, if any.
666 CreateOffloadingDeviceToolChains(*C, Inputs);
Justin Lebar0e450a52016-03-30 23:30:25 +0000667
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000668 // Construct the list of abstract actions to perform for this compilation. On
Tim Northover157d9112014-01-16 08:48:16 +0000669 // MachO targets this uses the driver-driver and universal actions.
670 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000671 BuildUniversalActions(*C, C->getDefaultToolChain(), Inputs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000672 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000673 BuildActions(*C, C->getArgs(), Inputs, C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000674
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +0000675 if (CCCPrintPhases) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000676 PrintActions(*C);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000677 return C;
678 }
679
680 BuildJobs(*C);
Daniel Dunbaradc91e62009-03-15 01:38:15 +0000681
682 return C;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000683}
684
Justin Bognered9cbe02015-07-09 06:58:31 +0000685static void printArgList(raw_ostream &OS, const llvm::opt::ArgList &Args) {
686 llvm::opt::ArgStringList ASL;
687 for (const auto *A : Args)
688 A->render(Args, ASL);
689
690 for (auto I = ASL.begin(), E = ASL.end(); I != E; ++I) {
691 if (I != ASL.begin())
692 OS << ' ';
693 Command::printArg(OS, *I, true);
694 }
695 OS << '\n';
696}
697
Eric Christopherf901e852011-08-17 22:59:59 +0000698// When clang crashes, produce diagnostic information including the fully
699// preprocessed source file(s). Request that the developer attach the
Chad Rosierbe10f982011-08-02 17:58:04 +0000700// diagnostic information to a bug report.
701void Driver::generateCompilationDiagnostics(Compilation &C,
Justin Bognere1a33d12014-10-20 21:02:05 +0000702 const Command &FailingCommand) {
Chad Rosier877c0a22012-02-22 00:30:39 +0000703 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
Chad Rosier62135492012-07-09 17:31:28 +0000704 return;
Chad Rosierbee5a1d2012-03-07 00:30:40 +0000705
Chad Rosierdbf46a12013-02-01 18:30:26 +0000706 // Don't try to generate diagnostics for link or dsymutil jobs.
Justin Bognere1a33d12014-10-20 21:02:05 +0000707 if (FailingCommand.getCreator().isLinkJob() ||
708 FailingCommand.getCreator().isDsymutilJob())
Chad Rosier877c0a22012-02-22 00:30:39 +0000709 return;
710
Chad Rosier8179f112012-06-19 17:51:34 +0000711 // Print the version of the compiler.
712 PrintVersion(C, llvm::errs());
713
Chad Rosierbe10f982011-08-02 17:58:04 +0000714 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000715 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
716 "crash backtrace, preprocessed source, and associated run script.";
Chad Rosierbe10f982011-08-02 17:58:04 +0000717
718 // Suppress driver output and emit preprocessor output to temp file.
Hans Wennborg70850d82013-07-18 20:29:38 +0000719 Mode = CPPMode;
Chad Rosierbe10f982011-08-02 17:58:04 +0000720 CCGenDiagnostics = true;
721
Chad Rosiercdb008d2011-11-02 21:29:05 +0000722 // Save the original job command(s).
Justin Bogner25645152014-10-21 17:24:44 +0000723 Command Cmd = FailingCommand;
Chad Rosiercdb008d2011-11-02 21:29:05 +0000724
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000725 // Keep track of whether we produce any errors while trying to produce
726 // preprocessed sources.
727 DiagnosticErrorTrap Trap(Diags);
728
729 // Suppress tool output.
Chad Rosierbe10f982011-08-02 17:58:04 +0000730 C.initCompilationForDiagnostics();
Chad Rosierecdede82011-08-12 22:08:57 +0000731
732 // Construct the list of inputs.
733 InputList Inputs;
734 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000735
Chad Rosier4f81fc22011-08-12 23:30:05 +0000736 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000737 bool IgnoreInput = false;
738
739 // Ignore input from stdin or any inputs that cannot be preprocessed.
Paul Robinsonf44157d2014-04-28 22:24:44 +0000740 // Check type first as not all linker inputs have a value.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000741 if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
Paul Robinsonf44157d2014-04-28 22:24:44 +0000742 IgnoreInput = true;
743 } else if (!strcmp(it->second->getValue(), "-")) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000744 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000745 << "Error generating preprocessed source(s) - "
746 "ignoring input from stdin.";
Chad Rosierd57133d2011-08-18 00:22:25 +0000747 IgnoreInput = true;
Chad Rosierd57133d2011-08-18 00:22:25 +0000748 }
749
750 if (IgnoreInput) {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000751 it = Inputs.erase(it);
752 ie = Inputs.end();
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000753 } else {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000754 ++it;
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000755 }
Chad Rosier4f81fc22011-08-12 23:30:05 +0000756 }
Chad Rosierd57133d2011-08-18 00:22:25 +0000757
Chad Rosierc5103c32013-01-29 23:57:10 +0000758 if (Inputs.empty()) {
759 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000760 << "Error generating preprocessed source(s) - "
761 "no preprocessable inputs.";
Chad Rosierc5103c32013-01-29 23:57:10 +0000762 return;
763 }
764
Chad Rosiere75ef402011-09-06 23:52:36 +0000765 // Don't attempt to generate preprocessed files if multiple -arch options are
Chad Rosier636d2832012-02-13 18:16:28 +0000766 // used, unless they're all duplicates.
767 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +0000768 for (const Arg *A : C.getArgs()) {
Chad Rosiere75ef402011-09-06 23:52:36 +0000769 if (A->getOption().matches(options::OPT_arch)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000770 StringRef ArchName = A->getValue();
Chad Rosier636d2832012-02-13 18:16:28 +0000771 ArchNames.insert(ArchName);
Chad Rosiere75ef402011-09-06 23:52:36 +0000772 }
773 }
Chad Rosier636d2832012-02-13 18:16:28 +0000774 if (ArchNames.size() > 1) {
775 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000776 << "Error generating preprocessed source(s) - cannot generate "
777 "preprocessed source with multiple -arch options.";
Chad Rosier636d2832012-02-13 18:16:28 +0000778 return;
779 }
Chad Rosiere75ef402011-09-06 23:52:36 +0000780
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000781 // Construct the list of abstract actions to perform for this compilation. On
782 // Darwin OSes this uses the driver-driver and builds universal actions.
Chandler Carruthcb916192012-01-25 08:49:21 +0000783 const ToolChain &TC = C.getDefaultToolChain();
Tim Northover157d9112014-01-16 08:48:16 +0000784 if (TC.getTriple().isOSBinFormatMachO())
Artem Belevich5e2a3ec2015-11-17 22:28:40 +0000785 BuildUniversalActions(C, TC, Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000786 else
Justin Lebar0f3474c2016-02-11 02:00:50 +0000787 BuildActions(C, C.getArgs(), Inputs, C.getActions());
Chad Rosierbe10f982011-08-02 17:58:04 +0000788
789 BuildJobs(C);
790
791 // If there were errors building the compilation, quit now.
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000792 if (Trap.hasErrorOccurred()) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000793 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000794 << "Error generating preprocessed source(s).";
Chad Rosierbe10f982011-08-02 17:58:04 +0000795 return;
796 }
797
798 // Generate preprocessed output.
Chad Rosierdd60e092013-01-29 20:15:05 +0000799 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
Justin Bogner0cd92482015-07-02 22:52:08 +0000800 C.ExecuteJobs(C.getJobs(), FailingCommands);
Chad Rosierbe10f982011-08-02 17:58:04 +0000801
Justin Bognerbc89b182014-10-20 21:20:27 +0000802 // If any of the preprocessing commands failed, clean up and exit.
803 if (!FailingCommands.empty()) {
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000804 if (!isSaveTempsEnabled())
Chad Rosierbe10f982011-08-02 17:58:04 +0000805 C.CleanupFileList(C.getTempFiles(), true);
806
807 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000808 << "Error generating preprocessed source(s).";
Justin Bognerbc89b182014-10-20 21:20:27 +0000809 return;
Chad Rosierbe10f982011-08-02 17:58:04 +0000810 }
Justin Bognerbc89b182014-10-20 21:20:27 +0000811
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000812 const ArgStringList &TempFiles = C.getTempFiles();
813 if (TempFiles.empty()) {
814 Diag(clang::diag::note_drv_command_failed_diag_msg)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000815 << "Error generating preprocessed source(s).";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000816 return;
817 }
818
Justin Bognerbc89b182014-10-20 21:20:27 +0000819 Diag(clang::diag::note_drv_command_failed_diag_msg)
820 << "\n********************\n\n"
821 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
822 "Preprocessed source(s) and associated run script(s) are located at:";
Justin Bognerbc89b182014-10-20 21:20:27 +0000823
Justin Bogner659ecc32014-10-20 22:47:23 +0000824 SmallString<128> VFS;
825 for (const char *TempFile : TempFiles) {
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000826 Diag(clang::diag::note_drv_command_failed_diag_msg) << TempFile;
Justin Bogner659ecc32014-10-20 22:47:23 +0000827 if (StringRef(TempFile).endswith(".cache")) {
828 // In some cases (modules) we'll dump extra data to help with reproducing
829 // the crash into a directory next to the output.
830 VFS = llvm::sys::path::filename(TempFile);
831 llvm::sys::path::append(VFS, "vfs", "vfs.yaml");
832 }
833 }
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000834
835 // Assume associated files are based off of the first temporary file.
Justin Bogner25645152014-10-21 17:24:44 +0000836 CrashReportInfo CrashInfo(TempFiles[0], VFS);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000837
Justin Bogner25645152014-10-21 17:24:44 +0000838 std::string Script = CrashInfo.Filename.rsplit('.').first.str() + ".sh";
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000839 std::error_code EC;
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000840 llvm::raw_fd_ostream ScriptOS(Script, EC, llvm::sys::fs::F_Excl);
841 if (EC) {
842 Diag(clang::diag::note_drv_command_failed_diag_msg)
843 << "Error generating run script: " + Script + " " + EC.message();
844 } else {
Justin Bogner42220ed2015-03-12 00:14:35 +0000845 ScriptOS << "# Crash reproducer for " << getClangFullVersion() << "\n"
Justin Bognered9cbe02015-07-09 06:58:31 +0000846 << "# Driver args: ";
847 printArgList(ScriptOS, C.getInputArgs());
848 ScriptOS << "# Original command: ";
Justin Bogner42220ed2015-03-12 00:14:35 +0000849 Cmd.Print(ScriptOS, "\n", /*Quote=*/true);
Justin Bogner33bdbc62014-10-21 18:03:08 +0000850 Cmd.Print(ScriptOS, "\n", /*Quote=*/true, &CrashInfo);
Justin Bognerc1fdf7f2014-10-20 21:47:56 +0000851 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
Justin Bognerbc89b182014-10-20 21:20:27 +0000852 }
Saleem Abdulrasool3661a822015-01-12 02:33:09 +0000853
854 for (const auto &A : C.getArgs().filtered(options::OPT_frewrite_map_file,
855 options::OPT_frewrite_map_file_EQ))
856 Diag(clang::diag::note_drv_command_failed_diag_msg) << A->getValue();
857
Justin Bognerbc89b182014-10-20 21:20:27 +0000858 Diag(clang::diag::note_drv_command_failed_diag_msg)
859 << "\n\n********************";
Chad Rosierbe10f982011-08-02 17:58:04 +0000860}
861
Justin Bogner0cd92482015-07-02 22:52:08 +0000862void Driver::setUpResponseFiles(Compilation &C, Command &Cmd) {
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000863 // Since commandLineFitsWithinSystemLimits() may underestimate system's capacity
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000864 // if the tool does not support response files, there is a chance/ that things
865 // will just work without a response file, so we silently just skip it.
Justin Bogner0cd92482015-07-02 22:52:08 +0000866 if (Cmd.getCreator().getResponseFilesSupport() == Tool::RF_None ||
Oleg Ranevskyycd516372016-01-05 19:54:39 +0000867 llvm::sys::commandLineFitsWithinSystemLimits(Cmd.getExecutable(), Cmd.getArguments()))
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000868 return;
869
870 std::string TmpName = GetTemporaryPath("response", "txt");
Malcolm Parsonsf76f6502016-11-02 10:39:27 +0000871 Cmd.setResponseFile(C.addTempFile(C.getArgs().MakeArgString(TmpName)));
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000872}
873
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000874int Driver::ExecuteCompilation(
875 Compilation &C,
876 SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) {
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000877 // Just print if -### was present.
878 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Hans Wennborgb212b342013-09-12 18:23:34 +0000879 C.getJobs().Print(llvm::errs(), "\n", true);
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000880 return 0;
881 }
882
883 // If there were errors building the compilation, quit now.
Chad Rosierbe10f982011-08-02 17:58:04 +0000884 if (Diags.hasErrorOccurred())
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000885 return 1;
886
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000887 // Set up response file names for each command, if necessary
Justin Bogner0cd92482015-07-02 22:52:08 +0000888 for (auto &Job : C.getJobs())
889 setUpResponseFiles(C, Job);
Reid Kleckner0290c9c2014-09-15 17:45:39 +0000890
Justin Bogner0cd92482015-07-02 22:52:08 +0000891 C.ExecuteJobs(C.getJobs(), FailingCommands);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000892
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000893 // Remove temp files.
894 C.CleanupFileList(C.getTempFiles());
895
Daniel Dunbar07494792010-05-22 00:37:20 +0000896 // If the command succeeded, we are done.
Chad Rosierdd60e092013-01-29 20:15:05 +0000897 if (FailingCommands.empty())
898 return 0;
Daniel Dunbar07494792010-05-22 00:37:20 +0000899
Chad Rosierdd60e092013-01-29 20:15:05 +0000900 // Otherwise, remove result files and print extra information about abnormal
901 // failures.
Douglas Katzman6bbffc42015-06-25 18:51:37 +0000902 for (const auto &CmdPair : FailingCommands) {
903 int Res = CmdPair.first;
904 const Command *FailingCommand = CmdPair.second;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000905
Chad Rosierdd60e092013-01-29 20:15:05 +0000906 // Remove result files if we're not saving temps.
Reid Kleckner68eb60b2015-02-02 22:41:48 +0000907 if (!isSaveTempsEnabled()) {
Chad Rosierdd60e092013-01-29 20:15:05 +0000908 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
909 C.CleanupFileMap(C.getResultFiles(), JA, true);
910
911 // Failure result files are valid unless we crashed.
912 if (Res < 0)
913 C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
914 }
915
916 // Print extra information about abnormal failures, if possible.
917 //
918 // This is ad-hoc, but we don't want to be excessively noisy. If the result
Justin Bogner5aaf2e72014-06-26 20:59:36 +0000919 // status was 1, assume the command failed normally. In particular, if it
Chad Rosierdd60e092013-01-29 20:15:05 +0000920 // was the compiler then assume it gave a reasonable error code. Failures
921 // in other tools are less common, and they generally have worse
922 // diagnostics, so always print the diagnostic there.
923 const Tool &FailingTool = FailingCommand->getCreator();
924
925 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
926 // FIXME: See FIXME above regarding result code interpretation.
927 if (Res < 0)
928 Diag(clang::diag::err_drv_command_signalled)
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000929 << FailingTool.getShortName();
Chad Rosierdd60e092013-01-29 20:15:05 +0000930 else
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000931 Diag(clang::diag::err_drv_command_failed) << FailingTool.getShortName()
932 << Res;
Chad Rosierdd60e092013-01-29 20:15:05 +0000933 }
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000934 }
Chad Rosierdd60e092013-01-29 20:15:05 +0000935 return 0;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000936}
937
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000938void Driver::PrintHelp(bool ShowHidden) const {
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000939 unsigned IncludedFlagsBitmask;
940 unsigned ExcludedFlagsBitmask;
Benjamin Kramer867ea1d2014-03-02 13:01:17 +0000941 std::tie(IncludedFlagsBitmask, ExcludedFlagsBitmask) =
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000942 getIncludeExcludeOptionFlagMasks();
Hans Wennborg6ddc6902013-07-27 00:23:45 +0000943
944 ExcludedFlagsBitmask |= options::NoDriverOption;
945 if (!ShowHidden)
946 ExcludedFlagsBitmask |= HelpHidden;
947
948 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
949 IncludedFlagsBitmask, ExcludedFlagsBitmask);
Daniel Dunbar7c925282009-03-31 21:38:17 +0000950}
951
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000952void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000953 // FIXME: The following handlers should use a callback mechanism, we don't
954 // know what the client would like to do.
Ted Kremenek4c0df3d2010-01-23 02:11:34 +0000955 OS << getClangFullVersion() << '\n';
Daniel Dunbarb10248802009-03-26 16:09:13 +0000956 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000957 OS << "Target: " << TC.getTripleString() << '\n';
Daniel Dunbar10978e42009-06-16 23:32:58 +0000958
959 // Print the threading model.
Jonathan Roelofsb140a102014-10-03 21:57:44 +0000960 if (Arg *A = C.getArgs().getLastArg(options::OPT_mthread_model)) {
961 // Don't print if the ToolChain would have barfed on it already
962 if (TC.isThreadModelSupported(A->getValue()))
963 OS << "Thread model: " << A->getValue();
964 } else
965 OS << "Thread model: " << TC.getThreadModel();
966 OS << '\n';
Chandler Carruth9ade6a92015-08-05 17:07:33 +0000967
968 // Print out the install directory.
969 OS << "InstalledDir: " << InstalledDir << '\n';
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000970}
971
Chris Lattner86ed5b02010-05-05 05:53:24 +0000972/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
973/// option.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000974static void PrintDiagnosticCategories(raw_ostream &OS) {
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000975 // Skip the empty category.
Douglas Katzmana67e50c2015-06-26 15:47:46 +0000976 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories(); i != max;
977 ++i)
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000978 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
Chris Lattner86ed5b02010-05-05 05:53:24 +0000979}
980
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000981bool Driver::HandleImmediateArgs(const Compilation &C) {
Daniel Dunbar18974bd2010-06-11 22:00:19 +0000982 // The order these options are handled in gcc is all over the place, but we
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000983 // don't expect inconsistencies w.r.t. that to matter in practice.
Daniel Dunbar7c925282009-03-31 21:38:17 +0000984
Daniel Dunbar1b09e042010-09-17 02:47:28 +0000985 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
986 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
987 return false;
988 }
989
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000990 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
Daniel Dunbare26e5002011-01-12 00:43:47 +0000991 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
992 // return an answer which matches our definition of __VERSION__.
993 //
994 // If we want to return a more correct answer some day, then we should
995 // introduce a non-pedantically GCC compatible mode to Clang in which we
996 // provide sensible definitions for -dumpversion, __VERSION__, etc.
997 llvm::outs() << "4.2.1\n";
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000998 return false;
999 }
Daniel Dunbarfb3d7472010-06-14 21:23:12 +00001000
Chris Lattner86ed5b02010-05-05 05:53:24 +00001001 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
1002 PrintDiagnosticCategories(llvm::outs());
1003 return false;
1004 }
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +00001005
James Molloya3c85b82012-05-01 14:57:16 +00001006 if (C.getArgs().hasArg(options::OPT_help) ||
Daniel Dunbara7b5e212009-04-15 16:34:29 +00001007 C.getArgs().hasArg(options::OPT__help_hidden)) {
1008 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +00001009 return false;
1010 }
1011
Daniel Dunbarb0006ae2009-04-02 15:05:41 +00001012 if (C.getArgs().hasArg(options::OPT__version)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001013 // Follow gcc behavior and use stdout for --version and stderr for -v.
Daniel Dunbar08e41d62009-07-21 20:06:58 +00001014 PrintVersion(C, llvm::outs());
Daniel Dunbarb0006ae2009-04-02 15:05:41 +00001015 return false;
1016 }
1017
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001018 if (C.getArgs().hasArg(options::OPT_v) ||
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001019 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Daniel Dunbar08e41d62009-07-21 20:06:58 +00001020 PrintVersion(C, llvm::errs());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001021 SuppressMissingInputWarning = true;
1022 }
1023
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001024 const ToolChain &TC = C.getDefaultToolChain();
Chandler Carruth0ae39aa2013-07-30 17:57:09 +00001025
1026 if (C.getArgs().hasArg(options::OPT_v))
1027 TC.printVerboseInfo(llvm::errs());
1028
Daniel Dunbard972e222009-03-20 04:37:21 +00001029 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
1030 llvm::outs() << "programs: =";
Douglas Katzman51fe7bf2015-06-23 22:43:50 +00001031 bool separator = false;
1032 for (const std::string &Path : TC.getProgramPaths()) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001033 if (separator)
1034 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +00001035 llvm::outs() << Path;
1036 separator = true;
Daniel Dunbard972e222009-03-20 04:37:21 +00001037 }
1038 llvm::outs() << "\n";
Peter Collingbournefa9771f2011-09-06 02:08:31 +00001039 llvm::outs() << "libraries: =" << ResourceDir;
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +00001040
Sebastian Pop980920a2012-04-16 04:16:43 +00001041 StringRef sysroot = C.getSysRoot();
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +00001042
Douglas Katzman51fe7bf2015-06-23 22:43:50 +00001043 for (const std::string &Path : TC.getFilePaths()) {
1044 // Always print a separator. ResourceDir was the first item shown.
Peter Collingbournefa9771f2011-09-06 02:08:31 +00001045 llvm::outs() << ':';
Douglas Katzman51fe7bf2015-06-23 22:43:50 +00001046 // Interpretation of leading '=' is needed only for NetBSD.
1047 if (Path[0] == '=')
Douglas Katzman26eabf62015-06-24 15:10:30 +00001048 llvm::outs() << sysroot << Path.substr(1);
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +00001049 else
Douglas Katzman51fe7bf2015-06-23 22:43:50 +00001050 llvm::outs() << Path;
Daniel Dunbard972e222009-03-20 04:37:21 +00001051 }
1052 llvm::outs() << "\n";
Daniel Dunbar7c925282009-03-31 21:38:17 +00001053 return false;
Daniel Dunbard972e222009-03-20 04:37:21 +00001054 }
1055
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001056 // FIXME: The following handlers should use a callback mechanism, we don't
1057 // know what the client would like to do.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001058 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001059 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001060 return false;
1061 }
1062
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001063 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001064 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001065 return false;
1066 }
1067
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001068 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
Michal Gorny7cfe4802016-10-10 12:23:40 +00001069 ToolChain::RuntimeLibType RLT = TC.GetRuntimeLibType(C.getArgs());
1070 switch (RLT) {
1071 case ToolChain::RLT_CompilerRT:
1072 llvm::outs() << TC.getCompilerRT(C.getArgs(), "builtins") << "\n";
1073 break;
1074 case ToolChain::RLT_Libgcc:
1075 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
1076 break;
1077 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001078 return false;
1079 }
1080
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +00001081 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +00001082 for (const Multilib &Multilib : TC.getMultilibs())
1083 llvm::outs() << Multilib << "\n";
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +00001084 return false;
1085 }
1086
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001087 if (C.getArgs().hasArg(options::OPT_print_multi_directory)) {
Douglas Katzmana34b7bf2015-06-30 19:32:57 +00001088 for (const Multilib &Multilib : TC.getMultilibs()) {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001089 if (Multilib.gccSuffix().empty())
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001090 llvm::outs() << ".\n";
1091 else {
Douglas Katzman6bbffc42015-06-25 18:51:37 +00001092 StringRef Suffix(Multilib.gccSuffix());
Jonathan Roelofs2cea1be2014-02-12 03:21:20 +00001093 assert(Suffix.front() == '/');
1094 llvm::outs() << Suffix.substr(1) << "\n";
1095 }
Jonathan Roelofs3fa96d82014-02-12 01:36:51 +00001096 }
Jonathan Roelofs0e7ec602014-02-12 01:29:25 +00001097 return false;
1098 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001099 return true;
1100}
1101
Douglas Katzmanfd528672015-06-11 15:05:22 +00001102// Display an action graph human-readably. Action A is the "sink" node
1103// and latest-occuring action. Traversal is in pre-order, visiting the
1104// inputs to each action before printing the action itself.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001105static unsigned PrintActions1(const Compilation &C, Action *A,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001106 std::map<Action *, unsigned> &Ids) {
Douglas Katzmanfd528672015-06-11 15:05:22 +00001107 if (Ids.count(A)) // A was already visited.
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001108 return Ids[A];
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001109
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001110 std::string str;
1111 llvm::raw_string_ostream os(str);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001112
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001113 os << Action::getClassName(A->getKind()) << ", ";
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001114 if (InputAction *IA = dyn_cast<InputAction>(A)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001115 os << "\"" << IA->getInputArg().getValue() << "\"";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001116 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001117 os << '"' << BIA->getArchName() << '"' << ", {"
Nico Weber5a459f82016-02-23 19:30:43 +00001118 << PrintActions1(C, *BIA->input_begin(), Ids) << "}";
Samuel Antaod06239d2016-07-15 23:13:27 +00001119 } else if (OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
1120 bool IsFirst = true;
1121 OA->doOnEachDependence(
1122 [&](Action *A, const ToolChain *TC, const char *BoundArch) {
1123 // E.g. for two CUDA device dependences whose bound arch is sm_20 and
1124 // sm_35 this will generate:
1125 // "cuda-device" (nvptx64-nvidia-cuda:sm_20) {#ID}, "cuda-device"
1126 // (nvptx64-nvidia-cuda:sm_35) {#ID}
1127 if (!IsFirst)
1128 os << ", ";
1129 os << '"';
1130 if (TC)
1131 os << A->getOffloadingKindPrefix();
1132 else
1133 os << "host";
1134 os << " (";
1135 os << TC->getTriple().normalize();
1136
1137 if (BoundArch)
1138 os << ":" << BoundArch;
1139 os << ")";
1140 os << '"';
1141 os << " {" << PrintActions1(C, A, Ids) << "}";
1142 IsFirst = false;
1143 });
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001144 } else {
Samuel Antaod06239d2016-07-15 23:13:27 +00001145 const ActionList *AL = &A->getInputs();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00001146
Artem Belevich23256752015-09-22 17:23:09 +00001147 if (AL->size()) {
1148 const char *Prefix = "{";
1149 for (Action *PreRequisite : *AL) {
1150 os << Prefix << PrintActions1(C, PreRequisite, Ids);
1151 Prefix = ", ";
1152 }
1153 os << "}";
1154 } else
1155 os << "{}";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001156 }
1157
Samuel Antaod06239d2016-07-15 23:13:27 +00001158 // Append offload info for all options other than the offloading action
1159 // itself (e.g. (cuda-device, sm_20) or (cuda-host)).
1160 std::string offload_str;
1161 llvm::raw_string_ostream offload_os(offload_str);
1162 if (!isa<OffloadAction>(A)) {
1163 auto S = A->getOffloadingKindPrefix();
1164 if (!S.empty()) {
1165 offload_os << ", (" << S;
1166 if (A->getOffloadingArch())
1167 offload_os << ", " << A->getOffloadingArch();
1168 offload_os << ")";
1169 }
1170 }
1171
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001172 unsigned Id = Ids.size();
1173 Ids[A] = Id;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001174 llvm::errs() << Id << ": " << os.str() << ", "
Samuel Antaod06239d2016-07-15 23:13:27 +00001175 << types::getTypeName(A->getType()) << offload_os.str() << "\n";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +00001176
1177 return Id;
1178}
1179
Douglas Katzmanfd528672015-06-11 15:05:22 +00001180// Print the action graphs in a compilation C.
1181// For example "clang -c file1.c file2.c" is composed of two subgraphs.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001182void Driver::PrintActions(const Compilation &C) const {
Douglas Katzmanb7e8ef02015-06-25 19:37:41 +00001183 std::map<Action *, unsigned> Ids;
1184 for (Action *A : C.getActions())
1185 PrintActions1(C, A, Ids);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001186}
1187
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +00001188/// \brief Check whether the given input tree contains any compilation or
1189/// assembly actions.
1190static bool ContainsCompileOrAssembleAction(const Action *A) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001191 if (isa<CompileJobAction>(A) || isa<BackendJobAction>(A) ||
Bob Wilson23a55f12014-12-21 07:00:00 +00001192 isa<AssembleJobAction>(A))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001193 return true;
1194
Nico Weber5a459f82016-02-23 19:30:43 +00001195 for (const Action *Input : A->inputs())
Nico Weberfb80f962015-09-19 21:36:51 +00001196 if (ContainsCompileOrAssembleAction(Input))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +00001197 return true;
1198
1199 return false;
1200}
1201
Artem Belevich5e2a3ec2015-11-17 22:28:40 +00001202void Driver::BuildUniversalActions(Compilation &C, const ToolChain &TC,
1203 const InputList &BAInputs) const {
1204 DerivedArgList &Args = C.getArgs();
1205 ActionList &Actions = C.getActions();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001206 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
1207 // Collect the list of architectures. Duplicates are allowed, but should only
1208 // be handled once (in the order seen).
Daniel Dunbare5dc4822009-03-13 20:33:35 +00001209 llvm::StringSet<> ArchNames;
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001210 SmallVector<const char *, 4> Archs;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001211 for (Arg *A : Args) {
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001212 if (A->getOption().matches(options::OPT_arch)) {
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001213 // Validate the option here; we don't save the type here because its
1214 // particular spelling may participate in other driver choices.
1215 llvm::Triple::ArchType Arch =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001216 tools::darwin::getArchTypeForMachOArchName(A->getValue());
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001217 if (Arch == llvm::Triple::UnknownArch) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001218 Diag(clang::diag::err_drv_invalid_arch_name) << A->getAsString(Args);
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +00001219 continue;
1220 }
1221
Daniel Dunbar2da02722009-03-19 07:55:12 +00001222 A->claim();
David Blaikie61b86d42014-11-19 02:56:13 +00001223 if (ArchNames.insert(A->getValue()).second)
Richard Smithbd55daf2012-11-01 04:30:05 +00001224 Archs.push_back(A->getValue());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001225 }
1226 }
1227
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001228 // When there is no explicit arch for this platform, make sure we still bind
1229 // the architecture (to the default) so that -Xarch_ is handled correctly.
Daniel Dunbareb843be2009-03-18 03:13:20 +00001230 if (!Archs.size())
Daniel Dunbarc3bd9f52012-11-08 03:38:26 +00001231 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001232
Daniel Dunbarf479c122009-03-12 18:40:18 +00001233 ActionList SingleActions;
Justin Lebar0f3474c2016-02-11 02:00:50 +00001234 BuildActions(C, Args, BAInputs, SingleActions);
Daniel Dunbarf479c122009-03-12 18:40:18 +00001235
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001236 // Add in arch bindings for every top level action, as well as lipo and
1237 // dsymutil steps if needed.
Nico Weberfb80f962015-09-19 21:36:51 +00001238 for (Action* Act : SingleActions) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001239 // Make sure we can lipo this kind of output. If not (and it is an actual
1240 // output) then we disallow, since we can't create an output file with the
1241 // right name without overwriting it. We could remove this oddity by just
1242 // changing the output names to include the arch, which would also fix
Daniel Dunbarf479c122009-03-12 18:40:18 +00001243 // -save-temps. Compatibility wins for now.
1244
Daniel Dunbare2ca3bd2009-03-13 17:46:02 +00001245 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
Daniel Dunbarf479c122009-03-12 18:40:18 +00001246 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001247 << types::getTypeName(Act->getType());
Daniel Dunbarf479c122009-03-12 18:40:18 +00001248
1249 ActionList Inputs;
Justin Lebar41094612016-01-11 23:07:27 +00001250 for (unsigned i = 0, e = Archs.size(); i != e; ++i)
1251 Inputs.push_back(C.MakeAction<BindArchAction>(Act, Archs[i]));
Daniel Dunbarf479c122009-03-12 18:40:18 +00001252
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001253 // Lipo if necessary, we do it this way because we need to set the arch flag
1254 // so that -Xarch_ gets overwritten.
Daniel Dunbarf479c122009-03-12 18:40:18 +00001255 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
1256 Actions.append(Inputs.begin(), Inputs.end());
1257 else
Justin Lebar41094612016-01-11 23:07:27 +00001258 Actions.push_back(C.MakeAction<LipoJobAction>(Inputs, Act->getType()));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001259
Eric Christopher65c05fa2012-02-06 19:43:51 +00001260 // Handle debug info queries.
1261 Arg *A = Args.getLastArg(options::OPT_g_Group);
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001262 if (A && !A->getOption().matches(options::OPT_g0) &&
1263 !A->getOption().matches(options::OPT_gstabs) &&
1264 ContainsCompileOrAssembleAction(Actions.back())) {
Chad Rosier62135492012-07-09 17:31:28 +00001265
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001266 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
1267 // have a compile input. We need to run 'dsymutil' ourselves in such cases
Eric Christopher776c26f2013-01-28 17:39:03 +00001268 // because the debug info will refer to a temporary object file which
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001269 // will be removed at the end of the compilation process.
1270 if (Act->getType() == types::TY_Image) {
1271 ActionList Inputs;
1272 Inputs.push_back(Actions.back());
1273 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001274 Actions.push_back(
1275 C.MakeAction<DsymutilJobAction>(Inputs, types::TY_dSYM));
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001276 }
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001277
Ben Langmuir9b9a8d32014-02-06 18:53:25 +00001278 // Verify the debug info output.
Alp Tokere9d2bfc2014-01-17 02:06:23 +00001279 if (Args.hasArg(options::OPT_verify_debug_info)) {
Justin Lebar41094612016-01-11 23:07:27 +00001280 Action* LastAction = Actions.back();
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001281 Actions.pop_back();
Justin Lebar41094612016-01-11 23:07:27 +00001282 Actions.push_back(C.MakeAction<VerifyDebugInfoJobAction>(
1283 LastAction, types::TY_Nothing));
David Blaikie6f9f4eb2012-04-15 21:22:10 +00001284 }
1285 }
Daniel Dunbarf479c122009-03-12 18:40:18 +00001286 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001287}
1288
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001289/// \brief Check that the file referenced by Value exists. If it doesn't,
1290/// issue a diagnostic and return false.
Alp Toker8c8a8752013-12-03 06:53:35 +00001291static bool DiagnoseInputExistence(const Driver &D, const DerivedArgList &Args,
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001292 StringRef Value, types::ID Ty) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001293 if (!D.getCheckInputsExist())
1294 return true;
1295
1296 // stdin always exists.
1297 if (Value == "-")
1298 return true;
1299
1300 SmallString<64> Path(Value);
1301 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
Yaron Keren92e1b622015-03-18 10:17:07 +00001302 if (!llvm::sys::path::is_absolute(Path)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001303 SmallString<64> Directory(WorkDir->getValue());
1304 llvm::sys::path::append(Directory, Value);
1305 Path.assign(Directory);
1306 }
1307 }
1308
1309 if (llvm::sys::fs::exists(Twine(Path)))
1310 return true;
1311
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001312 if (D.IsCLMode()) {
1313 if (!llvm::sys::path::is_absolute(Twine(Path)) &&
1314 llvm::sys::Process::FindInEnvPath("LIB", Value))
1315 return true;
1316
1317 if (Args.hasArg(options::OPT__SLASH_link) && Ty == types::TY_Object) {
1318 // Arguments to the /link flag might cause the linker to search for object
1319 // and library files in paths we don't know about. Don't error in such
1320 // cases.
1321 return true;
1322 }
1323 }
Hans Wennborg23d26a32014-06-18 17:21:50 +00001324
Yaron Keren92e1b622015-03-18 10:17:07 +00001325 D.Diag(clang::diag::err_drv_no_such_file) << Path;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001326 return false;
1327}
1328
Chad Rosierecdede82011-08-12 22:08:57 +00001329// Construct a the list of inputs and their types.
Hans Wennborg55362852014-05-02 22:55:30 +00001330void Driver::BuildInputs(const ToolChain &TC, DerivedArgList &Args,
Chad Rosierecdede82011-08-12 22:08:57 +00001331 InputList &Inputs) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001332 // Track the current user specified (-x) input. We also explicitly track the
1333 // argument used to set the type; we only want to claim the type when we
1334 // actually use it, so we warn about unused -x arguments.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001335 types::ID InputType = types::TY_Nothing;
Craig Topper92fc2df2014-05-17 16:56:41 +00001336 Arg *InputTypeArg = nullptr;
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001337
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001338 // The last /TC or /TP option sets the input type to C or C++ globally.
Ehsan Akhgaric249abb2014-09-12 21:44:24 +00001339 if (Arg *TCTP = Args.getLastArgNoClaim(options::OPT__SLASH_TC,
1340 options::OPT__SLASH_TP)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001341 InputTypeArg = TCTP;
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001342 InputType = TCTP->getOption().matches(options::OPT__SLASH_TC)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001343 ? types::TY_C
1344 : types::TY_CXX;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001345
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001346 arg_iterator it =
1347 Args.filtered_begin(options::OPT__SLASH_TC, options::OPT__SLASH_TP);
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001348 const arg_iterator ie = Args.filtered_end();
1349 Arg *Previous = *it++;
1350 bool ShowNote = false;
1351 while (it != ie) {
Hans Wennborgd9ad0682013-09-11 16:38:41 +00001352 Diag(clang::diag::warn_drv_overriding_flag_option)
1353 << Previous->getSpelling() << (*it)->getSpelling();
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001354 Previous = *it++;
1355 ShowNote = true;
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001356 }
Hans Wennborg0d0b19c2013-08-12 18:34:17 +00001357 if (ShowNote)
1358 Diag(clang::diag::note_drv_t_option_is_global);
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001359
1360 // No driver mode exposes -x and /TC or /TP; we don't support mixing them.
1361 assert(!Args.hasArg(options::OPT_x) && "-x and /TC or /TP is not allowed");
1362 }
1363
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00001364 for (Arg *A : Args) {
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001365 if (A->getOption().getKind() == Option::InputClass) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001366 const char *Value = A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001367 types::ID Ty = types::TY_INVALID;
1368
1369 // Infer the input type if necessary.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +00001370 if (InputType == types::TY_Nothing) {
1371 // If there was an explicit arg for this, claim it.
1372 if (InputTypeArg)
1373 InputTypeArg->claim();
1374
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001375 // stdin must be handled specially.
1376 if (memcmp(Value, "-", 2) == 0) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001377 // If running with -E, treat as a C input (this changes the builtin
1378 // macros, for example). This may be overridden by -ObjC below.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001379 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001380 // Otherwise emit an error but still use a valid type to avoid
1381 // spurious errors (e.g., no inputs).
Hans Wennborg70850d82013-07-18 20:29:38 +00001382 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP())
Hans Wennborgcfdd8b52014-01-29 01:04:40 +00001383 Diag(IsCLMode() ? clang::diag::err_drv_unknown_stdin_type_clang_cl
1384 : clang::diag::err_drv_unknown_stdin_type);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001385 Ty = types::TY_C;
1386 } else {
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001387 // Otherwise lookup by extension.
1388 // Fallback is C if invoked as C preprocessor or Object otherwise.
1389 // We use a host hook here because Darwin at least has its own
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001390 // idea of what .s is.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001391 if (const char *Ext = strrchr(Value, '.'))
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +00001392 Ty = TC.LookupTypeForExtension(Ext + 1);
Daniel Dunbarea9f0322009-03-20 23:39:23 +00001393
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001394 if (Ty == types::TY_INVALID) {
Hans Wennborg70850d82013-07-18 20:29:38 +00001395 if (CCCIsCPP())
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +00001396 Ty = types::TY_C;
1397 else
1398 Ty = types::TY_Object;
1399 }
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001400
1401 // If the driver is invoked as C++ compiler (like clang++ or c++) it
1402 // should autodetect some input files as C++ for g++ compatibility.
Hans Wennborg70850d82013-07-18 20:29:38 +00001403 if (CCCIsCXX()) {
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001404 types::ID OldTy = Ty;
1405 Ty = types::lookupCXXTypeForCType(Ty);
1406
1407 if (Ty != OldTy)
1408 Diag(clang::diag::warn_drv_treating_input_as_cxx)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00001409 << getTypeName(OldTy) << getTypeName(Ty);
Daniel Dunbar0ac94452010-02-17 20:32:58 +00001410 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001411 }
1412
Daniel Dunbar82b22102009-05-18 21:47:54 +00001413 // -ObjC and -ObjC++ override the default language, but only for "source
1414 // files". We just treat everything that isn't a linker input as a
1415 // source file.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001416 //
Daniel Dunbar82b22102009-05-18 21:47:54 +00001417 // FIXME: Clean this up if we move the phase sequence into the type.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001418 if (Ty != types::TY_Object) {
1419 if (Args.hasArg(options::OPT_ObjC))
1420 Ty = types::TY_ObjC;
1421 else if (Args.hasArg(options::OPT_ObjCXX))
1422 Ty = types::TY_ObjCXX;
1423 }
1424 } else {
1425 assert(InputTypeArg && "InputType set w/o InputTypeArg");
Ehsan Akhgari7e954ea2014-09-12 18:15:10 +00001426 if (!InputTypeArg->getOption().matches(options::OPT_x)) {
1427 // If emulating cl.exe, make sure that /TC and /TP don't affect input
1428 // object files.
1429 const char *Ext = strrchr(Value, '.');
1430 if (Ext && TC.LookupTypeForExtension(Ext + 1) == types::TY_Object)
1431 Ty = types::TY_Object;
1432 }
1433 if (Ty == types::TY_INVALID) {
1434 Ty = InputType;
1435 InputTypeArg->claim();
1436 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001437 }
1438
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001439 if (DiagnoseInputExistence(*this, Args, Value, Ty))
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001440 Inputs.push_back(std::make_pair(Ty, A));
1441
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001442 } else if (A->getOption().matches(options::OPT__SLASH_Tc)) {
1443 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001444 if (DiagnoseInputExistence(*this, Args, Value, types::TY_C)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001445 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1446 Inputs.push_back(std::make_pair(types::TY_C, InputArg));
1447 }
1448 A->claim();
1449 } else if (A->getOption().matches(options::OPT__SLASH_Tp)) {
1450 StringRef Value = A->getValue();
Hans Wennborg12f4f8b2016-04-15 01:12:32 +00001451 if (DiagnoseInputExistence(*this, Args, Value, types::TY_CXX)) {
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001452 Arg *InputArg = MakeInputArg(Args, Opts, A->getValue());
1453 Inputs.push_back(std::make_pair(types::TY_CXX, InputArg));
1454 }
1455 A->claim();
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001456 } else if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001457 // Just treat as object type, we could make a special type for this if
1458 // necessary.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001459 Inputs.push_back(std::make_pair(types::TY_Object, A));
1460
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +00001461 } else if (A->getOption().matches(options::OPT_x)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001462 InputTypeArg = A;
Richard Smithbd55daf2012-11-01 04:30:05 +00001463 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
Chad Rosier706c2352012-04-07 00:01:31 +00001464 A->claim();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001465
1466 // Follow gcc behavior and treat as linker input for invalid -x
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001467 // options. Its not clear why we shouldn't just revert to unknown; but
Michael J. Spencer1a4fe8c2010-12-17 21:22:33 +00001468 // this isn't very important, we might as well be bug compatible.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001469 if (!InputType) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001470 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001471 InputType = types::TY_Object;
1472 }
1473 }
1474 }
Hans Wennborg70850d82013-07-18 20:29:38 +00001475 if (CCCIsCPP() && Inputs.empty()) {
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001476 // If called as standalone preprocessor, stdin is processed
1477 // if no other input is present.
Hans Wennborg6ee64d52013-08-06 00:20:31 +00001478 Arg *A = MakeInputArg(Args, Opts, "-");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001479 Inputs.push_back(std::make_pair(types::TY_C, A));
1480 }
Chad Rosierecdede82011-08-12 22:08:57 +00001481}
1482
Samuel Antao64e965e2016-09-30 15:34:19 +00001483namespace {
1484/// Provides a convenient interface for different programming models to generate
1485/// the required device actions.
1486class OffloadingActionBuilder final {
1487 /// Flag used to trace errors in the builder.
1488 bool IsValid = false;
1489
1490 /// The compilation that is using this builder.
1491 Compilation &C;
1492
Samuel Antao64e965e2016-09-30 15:34:19 +00001493 /// Map between an input argument and the offload kinds used to process it.
1494 std::map<const Arg *, unsigned> InputArgToOffloadKindMap;
1495
1496 /// Builder interface. It doesn't build anything or keep any state.
1497 class DeviceActionBuilder {
1498 public:
1499 typedef llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PhasesTy;
1500
1501 enum ActionBuilderReturnCode {
1502 // The builder acted successfully on the current action.
1503 ABRT_Success,
1504 // The builder didn't have to act on the current action.
1505 ABRT_Inactive,
1506 // The builder was successful and requested the host action to not be
1507 // generated.
1508 ABRT_Ignore_Host,
1509 };
1510
1511 protected:
1512 /// Compilation associated with this builder.
1513 Compilation &C;
1514
1515 /// Tool chains associated with this builder. The same programming
1516 /// model may have associated one or more tool chains.
1517 SmallVector<const ToolChain *, 2> ToolChains;
1518
1519 /// The derived arguments associated with this builder.
1520 DerivedArgList &Args;
1521
1522 /// The inputs associated with this builder.
1523 const Driver::InputList &Inputs;
1524
1525 /// The associated offload kind.
1526 Action::OffloadKind AssociatedOffloadKind = Action::OFK_None;
1527
1528 public:
1529 DeviceActionBuilder(Compilation &C, DerivedArgList &Args,
1530 const Driver::InputList &Inputs,
1531 Action::OffloadKind AssociatedOffloadKind)
1532 : C(C), Args(Args), Inputs(Inputs),
1533 AssociatedOffloadKind(AssociatedOffloadKind) {}
1534 virtual ~DeviceActionBuilder() {}
1535
1536 /// Fill up the array \a DA with all the device dependences that should be
1537 /// added to the provided host action \a HostAction. By default it is
1538 /// inactive.
1539 virtual ActionBuilderReturnCode
Samuel Antao28c4f182016-10-27 17:08:03 +00001540 getDeviceDependences(OffloadAction::DeviceDependences &DA,
1541 phases::ID CurPhase, phases::ID FinalPhase,
1542 PhasesTy &Phases) {
Samuel Antao64e965e2016-09-30 15:34:19 +00001543 return ABRT_Inactive;
1544 }
1545
1546 /// Update the state to include the provided host action \a HostAction as a
1547 /// dependency of the current device action. By default it is inactive.
1548 virtual ActionBuilderReturnCode addDeviceDepences(Action *HostAction) {
1549 return ABRT_Inactive;
1550 }
1551
1552 /// Append top level actions generated by the builder. Return true if errors
1553 /// were found.
1554 virtual void appendTopLevelActions(ActionList &AL) {}
1555
1556 /// Append linker actions generated by the builder. Return true if errors
1557 /// were found.
1558 virtual void appendLinkDependences(OffloadAction::DeviceDependences &DA) {}
1559
1560 /// Initialize the builder. Return true if any initialization errors are
1561 /// found.
1562 virtual bool initialize() { return false; }
1563
Samuel Antao69d6f312016-10-27 17:50:43 +00001564 /// Return true if the builder can use bundling/unbundling.
1565 virtual bool canUseBundlerUnbundler() const { return false; }
1566
Samuel Antao64e965e2016-09-30 15:34:19 +00001567 /// Return true if this builder is valid. We have a valid builder if we have
1568 /// associated device tool chains.
1569 bool isValid() { return !ToolChains.empty(); }
1570
1571 /// Return the associated offload kind.
1572 Action::OffloadKind getAssociatedOffloadKind() {
1573 return AssociatedOffloadKind;
1574 }
1575 };
1576
1577 /// \brief CUDA action builder. It injects device code in the host backend
1578 /// action.
1579 class CudaActionBuilder final : public DeviceActionBuilder {
1580 /// Flags to signal if the user requested host-only or device-only
1581 /// compilation.
1582 bool CompileHostOnly = false;
1583 bool CompileDeviceOnly = false;
1584
1585 /// List of GPU architectures to use in this compilation.
1586 SmallVector<CudaArch, 4> GpuArchList;
1587
1588 /// The CUDA actions for the current input.
1589 ActionList CudaDeviceActions;
1590
1591 /// The CUDA fat binary if it was generated for the current input.
1592 Action *CudaFatBinary = nullptr;
1593
1594 /// Flag that is set to true if this builder acted on the current input.
1595 bool IsActive = false;
1596
1597 public:
1598 CudaActionBuilder(Compilation &C, DerivedArgList &Args,
1599 const Driver::InputList &Inputs)
1600 : DeviceActionBuilder(C, Args, Inputs, Action::OFK_Cuda) {}
1601
1602 ActionBuilderReturnCode
Samuel Antao28c4f182016-10-27 17:08:03 +00001603 getDeviceDependences(OffloadAction::DeviceDependences &DA,
1604 phases::ID CurPhase, phases::ID FinalPhase,
1605 PhasesTy &Phases) override {
Samuel Antao64e965e2016-09-30 15:34:19 +00001606 if (!IsActive)
1607 return ABRT_Inactive;
1608
1609 // If we don't have more CUDA actions, we don't have any dependences to
1610 // create for the host.
1611 if (CudaDeviceActions.empty())
1612 return ABRT_Success;
1613
1614 assert(CudaDeviceActions.size() == GpuArchList.size() &&
1615 "Expecting one action per GPU architecture.");
1616 assert(!CompileHostOnly &&
1617 "Not expecting CUDA actions in host-only compilation.");
1618
1619 // If we are generating code for the device or we are in a backend phase,
1620 // we attempt to generate the fat binary. We compile each arch to ptx and
1621 // assemble to cubin, then feed the cubin *and* the ptx into a device
1622 // "link" action, which uses fatbinary to combine these cubins into one
1623 // fatbin. The fatbin is then an input to the host action if not in
1624 // device-only mode.
1625 if (CompileDeviceOnly || CurPhase == phases::Backend) {
1626 ActionList DeviceActions;
1627 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I) {
1628 // Produce the device action from the current phase up to the assemble
1629 // phase.
1630 for (auto Ph : Phases) {
1631 // Skip the phases that were already dealt with.
1632 if (Ph < CurPhase)
1633 continue;
1634 // We have to be consistent with the host final phase.
1635 if (Ph > FinalPhase)
1636 break;
1637
1638 CudaDeviceActions[I] = C.getDriver().ConstructPhaseAction(
1639 C, Args, Ph, CudaDeviceActions[I]);
1640
1641 if (Ph == phases::Assemble)
1642 break;
1643 }
1644
1645 // If we didn't reach the assemble phase, we can't generate the fat
1646 // binary. We don't need to generate the fat binary if we are not in
1647 // device-only mode.
1648 if (!isa<AssembleJobAction>(CudaDeviceActions[I]) ||
1649 CompileDeviceOnly)
1650 continue;
1651
1652 Action *AssembleAction = CudaDeviceActions[I];
1653 assert(AssembleAction->getType() == types::TY_Object);
1654 assert(AssembleAction->getInputs().size() == 1);
1655
1656 Action *BackendAction = AssembleAction->getInputs()[0];
1657 assert(BackendAction->getType() == types::TY_PP_Asm);
1658
1659 for (auto &A : {AssembleAction, BackendAction}) {
1660 OffloadAction::DeviceDependences DDep;
1661 DDep.add(*A, *ToolChains.front(), CudaArchToString(GpuArchList[I]),
1662 Action::OFK_Cuda);
1663 DeviceActions.push_back(
1664 C.MakeAction<OffloadAction>(DDep, A->getType()));
1665 }
1666 }
1667
1668 // We generate the fat binary if we have device input actions.
1669 if (!DeviceActions.empty()) {
1670 CudaFatBinary =
1671 C.MakeAction<LinkJobAction>(DeviceActions, types::TY_CUDA_FATBIN);
1672
1673 if (!CompileDeviceOnly) {
1674 DA.add(*CudaFatBinary, *ToolChains.front(), /*BoundArch=*/nullptr,
1675 Action::OFK_Cuda);
1676 // Clear the fat binary, it is already a dependence to an host
1677 // action.
1678 CudaFatBinary = nullptr;
1679 }
1680
1681 // Remove the CUDA actions as they are already connected to an host
1682 // action or fat binary.
1683 CudaDeviceActions.clear();
1684 }
1685
1686 // We avoid creating host action in device-only mode.
1687 return CompileDeviceOnly ? ABRT_Ignore_Host : ABRT_Success;
Samuel Antao5b1a89a2016-10-27 00:53:34 +00001688 } else if (CurPhase > phases::Backend) {
1689 // If we are past the backend phase and still have a device action, we
1690 // don't have to do anything as this action is already a device
1691 // top-level action.
1692 return ABRT_Success;
Samuel Antao64e965e2016-09-30 15:34:19 +00001693 }
1694
1695 assert(CurPhase < phases::Backend && "Generating single CUDA "
1696 "instructions should only occur "
1697 "before the backend phase!");
1698
1699 // By default, we produce an action for each device arch.
1700 for (Action *&A : CudaDeviceActions)
1701 A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A);
1702
1703 return ABRT_Success;
1704 }
1705
1706 ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override {
1707 // While generating code for CUDA, we only depend on the host input action
1708 // to trigger the creation of all the CUDA device actions.
1709
1710 // If we are dealing with an input action, replicate it for each GPU
1711 // architecture. If we are in host-only mode we return 'success' so that
1712 // the host uses the CUDA offload kind.
1713 if (auto *IA = dyn_cast<InputAction>(HostAction)) {
1714 assert(!GpuArchList.empty() &&
1715 "We should have at least one GPU architecture.");
1716
1717 // If the host input is not CUDA, we don't need to bother about this
1718 // input.
1719 if (IA->getType() != types::TY_CUDA) {
1720 // The builder will ignore this input.
1721 IsActive = false;
1722 return ABRT_Inactive;
1723 }
1724
1725 // Set the flag to true, so that the builder acts on the current input.
1726 IsActive = true;
1727
1728 if (CompileHostOnly)
1729 return ABRT_Success;
1730
1731 // Replicate inputs for each GPU architecture.
1732 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
1733 CudaDeviceActions.push_back(C.MakeAction<InputAction>(
1734 IA->getInputArg(), types::TY_CUDA_DEVICE));
1735
1736 return ABRT_Success;
1737 }
1738
1739 return IsActive ? ABRT_Success : ABRT_Inactive;
1740 }
1741
1742 void appendTopLevelActions(ActionList &AL) override {
1743 // Utility to append actions to the top level list.
1744 auto AddTopLevel = [&](Action *A, CudaArch BoundArch) {
1745 OffloadAction::DeviceDependences Dep;
1746 Dep.add(*A, *ToolChains.front(), CudaArchToString(BoundArch),
1747 Action::OFK_Cuda);
1748 AL.push_back(C.MakeAction<OffloadAction>(Dep, A->getType()));
1749 };
1750
1751 // If we have a fat binary, add it to the list.
1752 if (CudaFatBinary) {
1753 AddTopLevel(CudaFatBinary, CudaArch::UNKNOWN);
1754 CudaDeviceActions.clear();
1755 CudaFatBinary = nullptr;
1756 return;
1757 }
1758
1759 if (CudaDeviceActions.empty())
1760 return;
1761
1762 // If we have CUDA actions at this point, that's because we have a have
1763 // partial compilation, so we should have an action for each GPU
1764 // architecture.
1765 assert(CudaDeviceActions.size() == GpuArchList.size() &&
1766 "Expecting one action per GPU architecture.");
1767 assert(ToolChains.size() == 1 &&
1768 "Expecting to have a sing CUDA toolchain.");
1769 for (unsigned I = 0, E = GpuArchList.size(); I != E; ++I)
1770 AddTopLevel(CudaDeviceActions[I], GpuArchList[I]);
1771
1772 CudaDeviceActions.clear();
1773 }
1774
1775 bool initialize() override {
1776 // We don't need to support CUDA.
1777 if (!C.hasOffloadToolChain<Action::OFK_Cuda>())
1778 return false;
1779
1780 const ToolChain *HostTC = C.getSingleOffloadToolChain<Action::OFK_Host>();
1781 assert(HostTC && "No toolchain for host compilation.");
1782 if (HostTC->getTriple().isNVPTX()) {
1783 // We do not support targeting NVPTX for host compilation. Throw
1784 // an error and abort pipeline construction early so we don't trip
1785 // asserts that assume device-side compilation.
1786 C.getDriver().Diag(diag::err_drv_cuda_nvptx_host);
1787 return true;
1788 }
1789
1790 ToolChains.push_back(C.getSingleOffloadToolChain<Action::OFK_Cuda>());
1791
1792 Arg *PartialCompilationArg = Args.getLastArg(
1793 options::OPT_cuda_host_only, options::OPT_cuda_device_only,
1794 options::OPT_cuda_compile_host_device);
1795 CompileHostOnly = PartialCompilationArg &&
1796 PartialCompilationArg->getOption().matches(
1797 options::OPT_cuda_host_only);
1798 CompileDeviceOnly = PartialCompilationArg &&
1799 PartialCompilationArg->getOption().matches(
1800 options::OPT_cuda_device_only);
1801
1802 // Collect all cuda_gpu_arch parameters, removing duplicates.
1803 llvm::SmallSet<CudaArch, 4> GpuArchs;
1804 bool Error = false;
1805 for (Arg *A : Args) {
1806 if (!A->getOption().matches(options::OPT_cuda_gpu_arch_EQ))
1807 continue;
1808 A->claim();
1809
1810 const auto &ArchStr = A->getValue();
1811 CudaArch Arch = StringToCudaArch(ArchStr);
1812 if (Arch == CudaArch::UNKNOWN) {
1813 C.getDriver().Diag(clang::diag::err_drv_cuda_bad_gpu_arch) << ArchStr;
1814 Error = true;
1815 } else if (GpuArchs.insert(Arch).second)
1816 GpuArchList.push_back(Arch);
1817 }
1818
1819 // Default to sm_20 which is the lowest common denominator for supported
1820 // GPUs.
1821 // sm_20 code should work correctly, if suboptimally, on all newer GPUs.
1822 if (GpuArchList.empty())
1823 GpuArchList.push_back(CudaArch::SM_20);
1824
1825 return Error;
1826 }
1827 };
1828
Samuel Antao28c4f182016-10-27 17:08:03 +00001829 /// OpenMP action builder. The host bitcode is passed to the device frontend
1830 /// and all the device linked images are passed to the host link phase.
1831 class OpenMPActionBuilder final : public DeviceActionBuilder {
1832 /// The OpenMP actions for the current input.
1833 ActionList OpenMPDeviceActions;
1834
1835 /// The linker inputs obtained for each toolchain.
1836 SmallVector<ActionList, 8> DeviceLinkerInputs;
1837
1838 public:
1839 OpenMPActionBuilder(Compilation &C, DerivedArgList &Args,
1840 const Driver::InputList &Inputs)
1841 : DeviceActionBuilder(C, Args, Inputs, Action::OFK_OpenMP) {}
1842
1843 ActionBuilderReturnCode
1844 getDeviceDependences(OffloadAction::DeviceDependences &DA,
1845 phases::ID CurPhase, phases::ID FinalPhase,
1846 PhasesTy &Phases) override {
1847
1848 // We should always have an action for each input.
1849 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
1850 "Number of OpenMP actions and toolchains do not match.");
1851
1852 // The host only depends on device action in the linking phase, when all
1853 // the device images have to be embedded in the host image.
1854 if (CurPhase == phases::Link) {
1855 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
1856 "Toolchains and linker inputs sizes do not match.");
1857 auto LI = DeviceLinkerInputs.begin();
1858 for (auto *A : OpenMPDeviceActions) {
1859 LI->push_back(A);
1860 ++LI;
1861 }
1862
1863 // We passed the device action as a host dependence, so we don't need to
1864 // do anything else with them.
1865 OpenMPDeviceActions.clear();
1866 return ABRT_Success;
1867 }
1868
1869 // By default, we produce an action for each device arch.
1870 for (Action *&A : OpenMPDeviceActions)
1871 A = C.getDriver().ConstructPhaseAction(C, Args, CurPhase, A);
1872
1873 return ABRT_Success;
1874 }
1875
1876 ActionBuilderReturnCode addDeviceDepences(Action *HostAction) override {
1877
1878 // If this is an input action replicate it for each OpenMP toolchain.
1879 if (auto *IA = dyn_cast<InputAction>(HostAction)) {
1880 OpenMPDeviceActions.clear();
1881 for (unsigned I = 0; I < ToolChains.size(); ++I)
1882 OpenMPDeviceActions.push_back(
1883 C.MakeAction<InputAction>(IA->getInputArg(), IA->getType()));
1884 return ABRT_Success;
1885 }
1886
Samuel Antaofab4f372016-10-27 18:00:51 +00001887 // If this is an unbundling action use it as is for each OpenMP toolchain.
1888 if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(HostAction)) {
1889 OpenMPDeviceActions.clear();
1890 for (unsigned I = 0; I < ToolChains.size(); ++I) {
1891 OpenMPDeviceActions.push_back(UA);
1892 UA->registerDependentActionInfo(
1893 ToolChains[I], /*BoundArch=*/StringRef(), Action::OFK_OpenMP);
1894 }
1895 return ABRT_Success;
1896 }
1897
Samuel Antao28c4f182016-10-27 17:08:03 +00001898 // When generating code for OpenMP we use the host compile phase result as
1899 // a dependence to the device compile phase so that it can learn what
1900 // declarations should be emitted. However, this is not the only use for
1901 // the host action, so we prevent it from being collapsed.
1902 if (isa<CompileJobAction>(HostAction)) {
1903 HostAction->setCannotBeCollapsedWithNextDependentAction();
1904 assert(ToolChains.size() == OpenMPDeviceActions.size() &&
1905 "Toolchains and device action sizes do not match.");
1906 OffloadAction::HostDependence HDep(
1907 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
1908 /*BoundArch=*/nullptr, Action::OFK_OpenMP);
1909 auto TC = ToolChains.begin();
1910 for (Action *&A : OpenMPDeviceActions) {
1911 assert(isa<CompileJobAction>(A));
1912 OffloadAction::DeviceDependences DDep;
1913 DDep.add(*A, **TC, /*BoundArch=*/nullptr, Action::OFK_OpenMP);
1914 A = C.MakeAction<OffloadAction>(HDep, DDep);
1915 ++TC;
1916 }
1917 }
1918 return ABRT_Success;
1919 }
1920
Samuel Antao69d6f312016-10-27 17:50:43 +00001921 void appendTopLevelActions(ActionList &AL) override {
1922 if (OpenMPDeviceActions.empty())
1923 return;
1924
1925 // We should always have an action for each input.
1926 assert(OpenMPDeviceActions.size() == ToolChains.size() &&
1927 "Number of OpenMP actions and toolchains do not match.");
1928
1929 // Append all device actions followed by the proper offload action.
1930 auto TI = ToolChains.begin();
1931 for (auto *A : OpenMPDeviceActions) {
1932 OffloadAction::DeviceDependences Dep;
1933 Dep.add(*A, **TI, /*BoundArch=*/nullptr, Action::OFK_OpenMP);
1934 AL.push_back(C.MakeAction<OffloadAction>(Dep, A->getType()));
1935 ++TI;
1936 }
1937 // We no longer need the action stored in this builder.
1938 OpenMPDeviceActions.clear();
1939 }
1940
Samuel Antao28c4f182016-10-27 17:08:03 +00001941 void appendLinkDependences(OffloadAction::DeviceDependences &DA) override {
1942 assert(ToolChains.size() == DeviceLinkerInputs.size() &&
1943 "Toolchains and linker inputs sizes do not match.");
1944
1945 // Append a new link action for each device.
1946 auto TC = ToolChains.begin();
1947 for (auto &LI : DeviceLinkerInputs) {
1948 auto *DeviceLinkAction =
1949 C.MakeAction<LinkJobAction>(LI, types::TY_Image);
1950 DA.add(*DeviceLinkAction, **TC, /*BoundArch=*/nullptr,
1951 Action::OFK_OpenMP);
1952 ++TC;
1953 }
1954 }
1955
1956 bool initialize() override {
1957 // Get the OpenMP toolchains. If we don't get any, the action builder will
1958 // know there is nothing to do related to OpenMP offloading.
1959 auto OpenMPTCRange = C.getOffloadToolChains<Action::OFK_OpenMP>();
1960 for (auto TI = OpenMPTCRange.first, TE = OpenMPTCRange.second; TI != TE;
1961 ++TI)
1962 ToolChains.push_back(TI->second);
1963
1964 DeviceLinkerInputs.resize(ToolChains.size());
1965 return false;
1966 }
Samuel Antao69d6f312016-10-27 17:50:43 +00001967
1968 bool canUseBundlerUnbundler() const override {
1969 // OpenMP should use bundled files whenever possible.
1970 return true;
1971 }
Samuel Antao28c4f182016-10-27 17:08:03 +00001972 };
1973
1974 ///
1975 /// TODO: Add the implementation for other specialized builders here.
1976 ///
Samuel Antao64e965e2016-09-30 15:34:19 +00001977
1978 /// Specialized builders being used by this offloading action builder.
1979 SmallVector<DeviceActionBuilder *, 4> SpecializedBuilders;
1980
Samuel Antao69d6f312016-10-27 17:50:43 +00001981 /// Flag set to true if all valid builders allow file bundling/unbundling.
1982 bool CanUseBundler;
1983
Samuel Antao64e965e2016-09-30 15:34:19 +00001984public:
1985 OffloadingActionBuilder(Compilation &C, DerivedArgList &Args,
1986 const Driver::InputList &Inputs)
Samuel Antao10e905c2016-10-27 01:08:58 +00001987 : C(C) {
Samuel Antao64e965e2016-09-30 15:34:19 +00001988 // Create a specialized builder for each device toolchain.
1989
1990 IsValid = true;
1991
1992 // Create a specialized builder for CUDA.
1993 SpecializedBuilders.push_back(new CudaActionBuilder(C, Args, Inputs));
1994
Samuel Antao28c4f182016-10-27 17:08:03 +00001995 // Create a specialized builder for OpenMP.
1996 SpecializedBuilders.push_back(new OpenMPActionBuilder(C, Args, Inputs));
1997
Samuel Antao64e965e2016-09-30 15:34:19 +00001998 //
1999 // TODO: Build other specialized builders here.
2000 //
2001
Samuel Antao69d6f312016-10-27 17:50:43 +00002002 // Initialize all the builders, keeping track of errors. If all valid
2003 // builders agree that we can use bundling, set the flag to true.
2004 unsigned ValidBuilders = 0u;
2005 unsigned ValidBuildersSupportingBundling = 0u;
2006 for (auto *SB : SpecializedBuilders) {
Samuel Antao64e965e2016-09-30 15:34:19 +00002007 IsValid = IsValid && !SB->initialize();
Samuel Antao69d6f312016-10-27 17:50:43 +00002008
2009 // Update the counters if the builder is valid.
2010 if (SB->isValid()) {
2011 ++ValidBuilders;
2012 if (SB->canUseBundlerUnbundler())
2013 ++ValidBuildersSupportingBundling;
2014 }
2015 }
2016 CanUseBundler =
2017 ValidBuilders && ValidBuilders == ValidBuildersSupportingBundling;
Artem Belevichf981e30b2016-08-02 22:37:47 +00002018 }
Justin Lebardc3c5042016-04-19 02:27:07 +00002019
Samuel Antao64e965e2016-09-30 15:34:19 +00002020 ~OffloadingActionBuilder() {
2021 for (auto *SB : SpecializedBuilders)
2022 delete SB;
Samuel Antaod06239d2016-07-15 23:13:27 +00002023 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002024
Samuel Antao64e965e2016-09-30 15:34:19 +00002025 /// Generate an action that adds device dependences (if any) to a host action.
2026 /// If no device dependence actions exist, just return the host action \a
2027 /// HostAction. If an error is found or if no builder requires the host action
2028 /// to be generated, return nullptr.
2029 Action *
2030 addDeviceDependencesToHostAction(Action *HostAction, const Arg *InputArg,
2031 phases::ID CurPhase, phases::ID FinalPhase,
2032 DeviceActionBuilder::PhasesTy &Phases) {
2033 if (!IsValid)
2034 return nullptr;
Justin Lebar7bf77982016-01-11 23:27:13 +00002035
Samuel Antao64e965e2016-09-30 15:34:19 +00002036 if (SpecializedBuilders.empty())
2037 return HostAction;
2038
2039 assert(HostAction && "Invalid host action!");
2040
2041 OffloadAction::DeviceDependences DDeps;
2042 // Check if all the programming models agree we should not emit the host
2043 // action. Also, keep track of the offloading kinds employed.
2044 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2045 unsigned InactiveBuilders = 0u;
2046 unsigned IgnoringBuilders = 0u;
2047 for (auto *SB : SpecializedBuilders) {
2048 if (!SB->isValid()) {
2049 ++InactiveBuilders;
2050 continue;
2051 }
2052
Samuel Antao28c4f182016-10-27 17:08:03 +00002053 auto RetCode =
2054 SB->getDeviceDependences(DDeps, CurPhase, FinalPhase, Phases);
Samuel Antao64e965e2016-09-30 15:34:19 +00002055
2056 // If the builder explicitly says the host action should be ignored,
2057 // we need to increment the variable that tracks the builders that request
2058 // the host object to be ignored.
2059 if (RetCode == DeviceActionBuilder::ABRT_Ignore_Host)
2060 ++IgnoringBuilders;
2061
2062 // Unless the builder was inactive for this action, we have to record the
2063 // offload kind because the host will have to use it.
2064 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2065 OffloadKind |= SB->getAssociatedOffloadKind();
2066 }
2067
2068 // If all builders agree that the host object should be ignored, just return
2069 // nullptr.
2070 if (IgnoringBuilders &&
2071 SpecializedBuilders.size() == (InactiveBuilders + IgnoringBuilders))
2072 return nullptr;
2073
2074 if (DDeps.getActions().empty())
2075 return HostAction;
2076
2077 // We have dependences we need to bundle together. We use an offload action
2078 // for that.
2079 OffloadAction::HostDependence HDep(
2080 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
2081 /*BoundArch=*/nullptr, DDeps);
2082 return C.MakeAction<OffloadAction>(HDep, DDeps);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002083 }
2084
Samuel Antao64e965e2016-09-30 15:34:19 +00002085 /// Generate an action that adds a host dependence to a device action. The
2086 /// results will be kept in this action builder. Return true if an error was
2087 /// found.
Samuel Antaofab4f372016-10-27 18:00:51 +00002088 bool addHostDependenceToDeviceActions(Action *&HostAction,
Samuel Antao64e965e2016-09-30 15:34:19 +00002089 const Arg *InputArg) {
2090 if (!IsValid)
2091 return true;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002092
Samuel Antaofab4f372016-10-27 18:00:51 +00002093 // If we are supporting bundling/unbundling and the current action is an
2094 // input action of non-source file, we replace the host action by the
2095 // unbundling action. The bundler tool has the logic to detect if an input
2096 // is a bundle or not and if the input is not a bundle it assumes it is a
2097 // host file. Therefore it is safe to create an unbundling action even if
2098 // the input is not a bundle.
2099 if (CanUseBundler && isa<InputAction>(HostAction) &&
2100 InputArg->getOption().getKind() == llvm::opt::Option::InputClass &&
2101 !types::isSrcFile(HostAction->getType())) {
2102 auto UnbundlingHostAction =
2103 C.MakeAction<OffloadUnbundlingJobAction>(HostAction);
2104 UnbundlingHostAction->registerDependentActionInfo(
2105 C.getSingleOffloadToolChain<Action::OFK_Host>(),
2106 /*BoundArch=*/StringRef(), Action::OFK_Host);
2107 HostAction = UnbundlingHostAction;
2108 }
2109
Samuel Antao64e965e2016-09-30 15:34:19 +00002110 assert(HostAction && "Invalid host action!");
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002111
Samuel Antao64e965e2016-09-30 15:34:19 +00002112 // Register the offload kinds that are used.
2113 auto &OffloadKind = InputArgToOffloadKindMap[InputArg];
2114 for (auto *SB : SpecializedBuilders) {
2115 if (!SB->isValid())
2116 continue;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002117
Samuel Antao64e965e2016-09-30 15:34:19 +00002118 auto RetCode = SB->addDeviceDepences(HostAction);
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002119
Samuel Antao64e965e2016-09-30 15:34:19 +00002120 // Host dependences for device actions are not compatible with that same
2121 // action being ignored.
2122 assert(RetCode != DeviceActionBuilder::ABRT_Ignore_Host &&
2123 "Host dependence not expected to be ignored.!");
Samuel Antaod06239d2016-07-15 23:13:27 +00002124
Samuel Antao64e965e2016-09-30 15:34:19 +00002125 // Unless the builder was inactive for this action, we have to record the
2126 // offload kind because the host will have to use it.
2127 if (RetCode != DeviceActionBuilder::ABRT_Inactive)
2128 OffloadKind |= SB->getAssociatedOffloadKind();
2129 }
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002130
Samuel Antao64e965e2016-09-30 15:34:19 +00002131 return false;
2132 }
2133
Samuel Antao69d6f312016-10-27 17:50:43 +00002134 /// Add the offloading top level actions to the provided action list. This
2135 /// function can replace the host action by a bundling action if the
2136 /// programming models allow it.
Samuel Antao64e965e2016-09-30 15:34:19 +00002137 bool appendTopLevelActions(ActionList &AL, Action *HostAction,
2138 const Arg *InputArg) {
Samuel Antao69d6f312016-10-27 17:50:43 +00002139 // Get the device actions to be appended.
2140 ActionList OffloadAL;
Samuel Antao64e965e2016-09-30 15:34:19 +00002141 for (auto *SB : SpecializedBuilders) {
2142 if (!SB->isValid())
2143 continue;
Samuel Antao69d6f312016-10-27 17:50:43 +00002144 SB->appendTopLevelActions(OffloadAL);
Samuel Antao64e965e2016-09-30 15:34:19 +00002145 }
2146
Samuel Antao69d6f312016-10-27 17:50:43 +00002147 // If we can use the bundler, replace the host action by the bundling one in
2148 // the resulting list. Otherwise, just append the device actions.
2149 if (CanUseBundler && !OffloadAL.empty()) {
2150 // Add the host action to the list in order to create the bundling action.
2151 OffloadAL.push_back(HostAction);
2152
2153 // We expect that the host action was just appended to the action list
2154 // before this method was called.
2155 assert(HostAction == AL.back() && "Host action not in the list??");
2156 HostAction = C.MakeAction<OffloadBundlingJobAction>(OffloadAL);
2157 AL.back() = HostAction;
2158 } else
2159 AL.append(OffloadAL.begin(), OffloadAL.end());
2160
Samuel Antao64e965e2016-09-30 15:34:19 +00002161 // Propagate to the current host action (if any) the offload information
2162 // associated with the current input.
2163 if (HostAction)
2164 HostAction->propagateHostOffloadInfo(InputArgToOffloadKindMap[InputArg],
2165 /*BoundArch=*/nullptr);
Samuel Antao64e965e2016-09-30 15:34:19 +00002166 return false;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002167 }
Artem Belevich5bde4e02015-07-20 20:02:54 +00002168
Samuel Antao64e965e2016-09-30 15:34:19 +00002169 /// Processes the host linker action. This currently consists of replacing it
2170 /// with an offload action if there are device link objects and propagate to
2171 /// the host action all the offload kinds used in the current compilation. The
2172 /// resulting action is returned.
2173 Action *processHostLinkAction(Action *HostAction) {
2174 // Add all the dependences from the device linking actions.
2175 OffloadAction::DeviceDependences DDeps;
2176 for (auto *SB : SpecializedBuilders) {
2177 if (!SB->isValid())
2178 continue;
Justin Lebar21e5d4f2016-01-14 21:41:27 +00002179
Samuel Antao64e965e2016-09-30 15:34:19 +00002180 SB->appendLinkDependences(DDeps);
Justin Lebar21e5d4f2016-01-14 21:41:27 +00002181 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002182
Samuel Antao64e965e2016-09-30 15:34:19 +00002183 // Calculate all the offload kinds used in the current compilation.
2184 unsigned ActiveOffloadKinds = 0u;
2185 for (auto &I : InputArgToOffloadKindMap)
2186 ActiveOffloadKinds |= I.second;
2187
2188 // If we don't have device dependencies, we don't have to create an offload
2189 // action.
2190 if (DDeps.getActions().empty()) {
2191 // Propagate all the active kinds to host action. Given that it is a link
2192 // action it is assumed to depend on all actions generated so far.
2193 HostAction->propagateHostOffloadInfo(ActiveOffloadKinds,
2194 /*BoundArch=*/nullptr);
2195 return HostAction;
2196 }
2197
2198 // Create the offload action with all dependences. When an offload action
2199 // is created the kinds are propagated to the host action, so we don't have
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002200 // to do that explicitly here.
Samuel Antao64e965e2016-09-30 15:34:19 +00002201 OffloadAction::HostDependence HDep(
2202 *HostAction, *C.getSingleOffloadToolChain<Action::OFK_Host>(),
2203 /*BoundArch*/ nullptr, ActiveOffloadKinds);
2204 return C.MakeAction<OffloadAction>(HDep, DDeps);
2205 }
2206};
2207} // anonymous namespace.
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002208
Justin Lebar0f3474c2016-02-11 02:00:50 +00002209void Driver::BuildActions(Compilation &C, DerivedArgList &Args,
2210 const InputList &Inputs, ActionList &Actions) const {
Chad Rosierecdede82011-08-12 22:08:57 +00002211 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00002212
Daniel Dunbar34c41872009-03-13 00:17:48 +00002213 if (!SuppressMissingInputWarning && Inputs.empty()) {
Daniel Dunbarbfeec742009-03-12 23:55:14 +00002214 Diag(clang::diag::err_drv_no_input_files);
2215 return;
2216 }
2217
Chad Rosier7742b5d2011-07-27 23:36:45 +00002218 Arg *FinalPhaseArg;
2219 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00002220
Rafael Espindolae8025642013-08-25 14:27:09 +00002221 if (FinalPhase == phases::Link && Args.hasArg(options::OPT_emit_llvm)) {
2222 Diag(clang::diag::err_drv_emit_llvm_link);
2223 }
2224
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002225 // Reject -Z* at the top level, these options should never have been exposed
2226 // by gcc.
Daniel Dunbardd765242009-03-26 16:12:09 +00002227 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Daniel Dunbar0e759942009-03-20 06:14:23 +00002228 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00002229
Hans Wennborg13b7fe72013-08-12 23:26:25 +00002230 // Diagnose misuse of /Fo.
2231 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fo)) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00002232 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00002233 if (Inputs.size() > 1 && !V.empty() &&
2234 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg13b7fe72013-08-12 23:26:25 +00002235 // Check whether /Fo tries to name an output file for multiple inputs.
Hans Wennborg9c1659b2013-10-18 22:49:04 +00002236 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002237 << A->getSpelling() << V;
Hans Wennborg13b7fe72013-08-12 23:26:25 +00002238 Args.eraseArg(options::OPT__SLASH_Fo);
2239 }
2240 }
2241
Hans Wennborg9c1659b2013-10-18 22:49:04 +00002242 // Diagnose misuse of /Fa.
2243 if (Arg *A = Args.getLastArg(options::OPT__SLASH_Fa)) {
2244 StringRef V = A->getValue();
Hans Wennborg61647532014-11-17 19:16:36 +00002245 if (Inputs.size() > 1 && !V.empty() &&
2246 !llvm::sys::path::is_separator(V.back())) {
Hans Wennborg9c1659b2013-10-18 22:49:04 +00002247 // Check whether /Fa tries to name an asm file for multiple inputs.
2248 Diag(clang::diag::err_drv_out_file_argument_with_multiple_sources)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002249 << A->getSpelling() << V;
Hans Wennborg9c1659b2013-10-18 22:49:04 +00002250 Args.eraseArg(options::OPT__SLASH_Fa);
2251 }
2252 }
2253
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00002254 // Diagnose misuse of /o.
2255 if (Arg *A = Args.getLastArg(options::OPT__SLASH_o)) {
2256 if (A->getValue()[0] == '\0') {
2257 // It has to have a value.
2258 Diag(clang::diag::err_drv_missing_argument) << A->getSpelling() << 1;
2259 Args.eraseArg(options::OPT__SLASH_o);
2260 }
2261 }
2262
Nico Weber2ca4be92016-03-01 23:16:44 +00002263 // Diagnose unsupported forms of /Yc /Yu. Ignore /Yc/Yu for now if:
2264 // * no filename after it
2265 // * both /Yc and /Yu passed but with different filenames
2266 // * corresponding file not also passed as /FI
2267 Arg *YcArg = Args.getLastArg(options::OPT__SLASH_Yc);
2268 Arg *YuArg = Args.getLastArg(options::OPT__SLASH_Yu);
2269 if (YcArg && YcArg->getValue()[0] == '\0') {
2270 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YcArg->getSpelling();
2271 Args.eraseArg(options::OPT__SLASH_Yc);
2272 YcArg = nullptr;
2273 }
2274 if (YuArg && YuArg->getValue()[0] == '\0') {
2275 Diag(clang::diag::warn_drv_ycyu_no_arg_clang_cl) << YuArg->getSpelling();
2276 Args.eraseArg(options::OPT__SLASH_Yu);
2277 YuArg = nullptr;
2278 }
2279 if (YcArg && YuArg && strcmp(YcArg->getValue(), YuArg->getValue()) != 0) {
2280 Diag(clang::diag::warn_drv_ycyu_different_arg_clang_cl);
2281 Args.eraseArg(options::OPT__SLASH_Yc);
2282 Args.eraseArg(options::OPT__SLASH_Yu);
2283 YcArg = YuArg = nullptr;
2284 }
2285 if (YcArg || YuArg) {
2286 StringRef Val = YcArg ? YcArg->getValue() : YuArg->getValue();
2287 bool FoundMatchingInclude = false;
2288 for (const Arg *Inc : Args.filtered(options::OPT_include)) {
2289 // FIXME: Do case-insensitive matching and consider / and \ as equal.
2290 if (Inc->getValue() == Val)
2291 FoundMatchingInclude = true;
2292 }
2293 if (!FoundMatchingInclude) {
2294 Diag(clang::diag::warn_drv_ycyu_no_fi_arg_clang_cl)
2295 << (YcArg ? YcArg : YuArg)->getSpelling();
2296 Args.eraseArg(options::OPT__SLASH_Yc);
2297 Args.eraseArg(options::OPT__SLASH_Yu);
2298 YcArg = YuArg = nullptr;
2299 }
2300 }
2301 if (YcArg && Inputs.size() > 1) {
2302 Diag(clang::diag::warn_drv_yc_multiple_inputs_clang_cl);
2303 Args.eraseArg(options::OPT__SLASH_Yc);
2304 YcArg = nullptr;
2305 }
2306 if (Args.hasArg(options::OPT__SLASH_Y_)) {
2307 // /Y- disables all pch handling. Rather than check for it everywhere,
2308 // just remove clang-cl pch-related flags here.
2309 Args.eraseArg(options::OPT__SLASH_Fp);
2310 Args.eraseArg(options::OPT__SLASH_Yc);
2311 Args.eraseArg(options::OPT__SLASH_Yu);
2312 YcArg = YuArg = nullptr;
2313 }
Nico Weber2ca4be92016-03-01 23:16:44 +00002314
Samuel Antao64e965e2016-09-30 15:34:19 +00002315 // Builder to be used to build offloading actions.
2316 OffloadingActionBuilder OffloadBuilder(C, Args, Inputs);
Samuel Antaod06239d2016-07-15 23:13:27 +00002317
Daniel Dunbar65229332009-03-13 11:38:42 +00002318 // Construct the actions to perform.
2319 ActionList LinkerInputs;
Alp Toker965f8822013-11-27 05:22:15 +00002320
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00002321 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
Artem Belevich5bde4e02015-07-20 20:02:54 +00002322 for (auto &I : Inputs) {
2323 types::ID InputType = I.first;
2324 const Arg *InputArg = I.second;
Daniel Dunbar65229332009-03-13 11:38:42 +00002325
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00002326 PL.clear();
2327 types::getCompilationPhases(InputType, PL);
Daniel Dunbar65229332009-03-13 11:38:42 +00002328
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002329 // If the first step comes after the final phase we are doing as part of
2330 // this compilation, warn the user about it.
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00002331 phases::ID InitialPhase = PL[0];
Daniel Dunbar65229332009-03-13 11:38:42 +00002332 if (InitialPhase > FinalPhase) {
Daniel Dunbaradc5c7c2009-03-19 07:57:08 +00002333 // Claim here to avoid the more general unused warning.
2334 InputArg->claim();
Daniel Dunbar07806ca2009-09-17 04:13:26 +00002335
Daniel Dunbar2db3e732011-04-20 15:44:48 +00002336 // Suppress all unused style warnings with -Qunused-arguments
2337 if (Args.hasArg(options::OPT_Qunused_arguments))
2338 continue;
2339
Richard Smith403f76e2012-08-06 04:09:06 +00002340 // Special case when final phase determined by binary name, rather than
2341 // by a command-line argument with a corresponding Arg.
Hans Wennborg70850d82013-07-18 20:29:38 +00002342 if (CCCIsCPP())
Richard Smith403f76e2012-08-06 04:09:06 +00002343 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002344 << InputArg->getAsString(Args) << getPhaseName(InitialPhase);
Daniel Dunbar07806ca2009-09-17 04:13:26 +00002345 // Special case '-E' warning on a previously preprocessed file to make
2346 // more sense.
Richard Smith403f76e2012-08-06 04:09:06 +00002347 else if (InitialPhase == phases::Compile &&
2348 FinalPhase == phases::Preprocess &&
2349 getPreprocessedType(InputType) == types::TY_INVALID)
Daniel Dunbar07806ca2009-09-17 04:13:26 +00002350 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002351 << InputArg->getAsString(Args) << !!FinalPhaseArg
2352 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar07806ca2009-09-17 04:13:26 +00002353 else
2354 Diag(clang::diag::warn_drv_input_file_unused)
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002355 << InputArg->getAsString(Args) << getPhaseName(InitialPhase)
2356 << !!FinalPhaseArg
2357 << (FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "");
Daniel Dunbar65229332009-03-13 11:38:42 +00002358 continue;
2359 }
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002360
Nico Weberad2d8f32016-04-21 19:59:10 +00002361 if (YcArg) {
2362 // Add a separate precompile phase for the compile phase.
2363 if (FinalPhase >= phases::Compile) {
Richard Smith8cd452d2016-08-30 18:55:16 +00002364 const types::ID HeaderType = lookupHeaderTypeForSourceType(InputType);
Nico Weberad2d8f32016-04-21 19:59:10 +00002365 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PCHPL;
Richard Smith8cd452d2016-08-30 18:55:16 +00002366 types::getCompilationPhases(HeaderType, PCHPL);
Nico Weberad2d8f32016-04-21 19:59:10 +00002367 Arg *PchInputArg = MakeInputArg(Args, Opts, YcArg->getValue());
2368
2369 // Build the pipeline for the pch file.
Richard Smith8cd452d2016-08-30 18:55:16 +00002370 Action *ClangClPch =
2371 C.MakeAction<InputAction>(*PchInputArg, HeaderType);
Nico Weberad2d8f32016-04-21 19:59:10 +00002372 for (phases::ID Phase : PCHPL)
2373 ClangClPch = ConstructPhaseAction(C, Args, Phase, ClangClPch);
2374 assert(ClangClPch);
2375 Actions.push_back(ClangClPch);
2376 // The driver currently exits after the first failed command. This
2377 // relies on that behavior, to make sure if the pch generation fails,
2378 // the main compilation won't run.
2379 }
2380 }
2381
Daniel Dunbar65229332009-03-13 11:38:42 +00002382 // Build the pipeline for this file.
Justin Lebar41094612016-01-11 23:07:27 +00002383 Action *Current = C.MakeAction<InputAction>(*InputArg, InputType);
Samuel Antao64e965e2016-09-30 15:34:19 +00002384
2385 // Use the current host action in any of the offloading actions, if
2386 // required.
2387 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2388 break;
2389
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002390 for (SmallVectorImpl<phases::ID>::iterator i = PL.begin(), e = PL.end();
2391 i != e; ++i) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00002392 phases::ID Phase = *i;
Daniel Dunbar65229332009-03-13 11:38:42 +00002393
2394 // We are done if this step is past what the user requested.
2395 if (Phase > FinalPhase)
2396 break;
2397
Samuel Antao64e965e2016-09-30 15:34:19 +00002398 // Add any offload action the host action depends on.
2399 Current = OffloadBuilder.addDeviceDependencesToHostAction(
2400 Current, InputArg, Phase, FinalPhase, PL);
2401 if (!Current)
2402 break;
2403
Daniel Dunbar65229332009-03-13 11:38:42 +00002404 // Queue linker inputs.
2405 if (Phase == phases::Link) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00002406 assert((i + 1) == e && "linking must be final compilation step.");
Justin Lebar41094612016-01-11 23:07:27 +00002407 LinkerInputs.push_back(Current);
2408 Current = nullptr;
Daniel Dunbar65229332009-03-13 11:38:42 +00002409 break;
2410 }
2411
Samuel Antao64e965e2016-09-30 15:34:19 +00002412 // Otherwise construct the appropriate action.
2413 auto *NewCurrent = ConstructPhaseAction(C, Args, Phase, Current);
2414
2415 // We didn't create a new action, so we will just move to the next phase.
2416 if (NewCurrent == Current)
Daniel Dunbar13864952009-03-24 20:17:30 +00002417 continue;
2418
Samuel Antao64e965e2016-09-30 15:34:19 +00002419 Current = NewCurrent;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002420
Samuel Antao64e965e2016-09-30 15:34:19 +00002421 // Use the current host action in any of the offloading actions, if
2422 // required.
2423 if (OffloadBuilder.addHostDependenceToDeviceActions(Current, InputArg))
2424 break;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00002425
Daniel Dunbar65229332009-03-13 11:38:42 +00002426 if (Current->getType() == types::TY_Nothing)
2427 break;
2428 }
2429
Samuel Antao64e965e2016-09-30 15:34:19 +00002430 // If we ended with something, add to the output list.
2431 if (Current)
Justin Lebar41094612016-01-11 23:07:27 +00002432 Actions.push_back(Current);
Samuel Antao64e965e2016-09-30 15:34:19 +00002433
2434 // Add any top level actions generated for offloading.
2435 OffloadBuilder.appendTopLevelActions(Actions, Current, InputArg);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00002436 }
Daniel Dunbar65229332009-03-13 11:38:42 +00002437
Samuel Antao64e965e2016-09-30 15:34:19 +00002438 // Add a link action if necessary.
Samuel Antaod06239d2016-07-15 23:13:27 +00002439 if (!LinkerInputs.empty()) {
Samuel Antao64e965e2016-09-30 15:34:19 +00002440 Action *LA = C.MakeAction<LinkJobAction>(LinkerInputs, types::TY_Image);
2441 LA = OffloadBuilder.processHostLinkAction(LA);
2442 Actions.push_back(LA);
Samuel Antaod06239d2016-07-15 23:13:27 +00002443 }
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00002444
2445 // If we are linking, claim any options which are obviously only used for
2446 // compilation.
Hans Wennborga8ef14f2013-09-17 00:03:41 +00002447 if (FinalPhase == phases::Link && PL.size() == 1) {
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00002448 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
Hans Wennborga8ef14f2013-09-17 00:03:41 +00002449 Args.ClaimAllArgs(options::OPT_cl_compile_Group);
2450 }
2451
2452 // Claim ignored clang-cl options.
2453 Args.ClaimAllArgs(options::OPT_cl_ignored_Group);
Artem Belevichbaae0932015-07-28 21:01:30 +00002454
Justin Lebardc3c5042016-04-19 02:27:07 +00002455 // Claim --cuda-host-only and --cuda-compile-host-device, which may be passed
2456 // to non-CUDA compilations and should not trigger warnings there.
Artem Belevichbaae0932015-07-28 21:01:30 +00002457 Args.ClaimAllArgs(options::OPT_cuda_host_only);
Justin Lebardc3c5042016-04-19 02:27:07 +00002458 Args.ClaimAllArgs(options::OPT_cuda_compile_host_device);
Daniel Dunbar65229332009-03-13 11:38:42 +00002459}
2460
Justin Lebar0f3474c2016-02-11 02:00:50 +00002461Action *Driver::ConstructPhaseAction(Compilation &C, const ArgList &Args,
2462 phases::ID Phase, Action *Input) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00002463 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
Samuel Antao64e965e2016-09-30 15:34:19 +00002464
2465 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
2466 // encode this in the steps because the intermediate type depends on
2467 // arguments. Just special case here.
2468 if (Phase == phases::Assemble && Input->getType() != types::TY_PP_Asm)
2469 return Input;
2470
Daniel Dunbar65229332009-03-13 11:38:42 +00002471 // Build the appropriate action.
2472 switch (Phase) {
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002473 case phases::Link:
2474 llvm_unreachable("link action invalid here.");
Daniel Dunbar65229332009-03-13 11:38:42 +00002475 case phases::Preprocess: {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002476 types::ID OutputTy;
2477 // -{M, MM} alter the output type.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +00002478 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00002479 OutputTy = types::TY_Dependencies;
2480 } else {
David Blaikie5d577a22012-06-29 22:03:56 +00002481 OutputTy = Input->getType();
2482 if (!Args.hasFlag(options::OPT_frewrite_includes,
Justin Bognerce8245b2014-06-24 08:01:01 +00002483 options::OPT_fno_rewrite_includes, false) &&
2484 !CCGenDiagnostics)
David Blaikie5d577a22012-06-29 22:03:56 +00002485 OutputTy = types::getPreprocessedType(OutputTy);
Daniel Dunbard67a3222009-03-30 06:36:42 +00002486 assert(OutputTy != types::TY_INVALID &&
2487 "Cannot preprocess this input type!");
2488 }
Justin Lebar41094612016-01-11 23:07:27 +00002489 return C.MakeAction<PreprocessJobAction>(Input, OutputTy);
Daniel Dunbar65229332009-03-13 11:38:42 +00002490 }
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002491 case phases::Precompile: {
Richard Smithdd4ad3d2016-08-30 19:06:26 +00002492 types::ID OutputTy = getPrecompiledType(Input->getType());
2493 assert(OutputTy != types::TY_INVALID &&
2494 "Cannot precompile this input type!");
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002495 if (Args.hasArg(options::OPT_fsyntax_only)) {
2496 // Syntax checks should not emit a PCH file
2497 OutputTy = types::TY_Nothing;
2498 }
Justin Lebar41094612016-01-11 23:07:27 +00002499 return C.MakeAction<PrecompileJobAction>(Input, OutputTy);
Aaron Ballman1f10cc52012-07-31 01:21:00 +00002500 }
Daniel Dunbar65229332009-03-13 11:38:42 +00002501 case phases::Compile: {
David Blaikie486f4402014-08-29 07:25:23 +00002502 if (Args.hasArg(options::OPT_fsyntax_only))
Justin Lebar41094612016-01-11 23:07:27 +00002503 return C.MakeAction<CompileJobAction>(Input, types::TY_Nothing);
David Blaikie486f4402014-08-29 07:25:23 +00002504 if (Args.hasArg(options::OPT_rewrite_objc))
Justin Lebar41094612016-01-11 23:07:27 +00002505 return C.MakeAction<CompileJobAction>(Input, types::TY_RewrittenObjC);
David Blaikie486f4402014-08-29 07:25:23 +00002506 if (Args.hasArg(options::OPT_rewrite_legacy_objc))
Justin Lebar41094612016-01-11 23:07:27 +00002507 return C.MakeAction<CompileJobAction>(Input,
2508 types::TY_RewrittenLegacyObjC);
David Blaikie486f4402014-08-29 07:25:23 +00002509 if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto))
Justin Lebar41094612016-01-11 23:07:27 +00002510 return C.MakeAction<AnalyzeJobAction>(Input, types::TY_Plist);
David Blaikie486f4402014-08-29 07:25:23 +00002511 if (Args.hasArg(options::OPT__migrate))
Justin Lebar41094612016-01-11 23:07:27 +00002512 return C.MakeAction<MigrateJobAction>(Input, types::TY_Remap);
David Blaikie486f4402014-08-29 07:25:23 +00002513 if (Args.hasArg(options::OPT_emit_ast))
Justin Lebar41094612016-01-11 23:07:27 +00002514 return C.MakeAction<CompileJobAction>(Input, types::TY_AST);
David Blaikie486f4402014-08-29 07:25:23 +00002515 if (Args.hasArg(options::OPT_module_file_info))
Justin Lebar41094612016-01-11 23:07:27 +00002516 return C.MakeAction<CompileJobAction>(Input, types::TY_ModuleFile);
David Blaikie486f4402014-08-29 07:25:23 +00002517 if (Args.hasArg(options::OPT_verify_pch))
Justin Lebar41094612016-01-11 23:07:27 +00002518 return C.MakeAction<VerifyPCHJobAction>(Input, types::TY_Nothing);
2519 return C.MakeAction<CompileJobAction>(Input, types::TY_LLVM_BC);
Bob Wilson23a55f12014-12-21 07:00:00 +00002520 }
2521 case phases::Backend: {
Teresa Johnson945bc502015-10-15 20:35:53 +00002522 if (isUsingLTO()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002523 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002524 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
Justin Lebar41094612016-01-11 23:07:27 +00002525 return C.MakeAction<BackendJobAction>(Input, Output);
David Blaikie486f4402014-08-29 07:25:23 +00002526 }
2527 if (Args.hasArg(options::OPT_emit_llvm)) {
Shuxin Yang4b3c7ff2013-08-23 21:34:57 +00002528 types::ID Output =
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002529 Args.hasArg(options::OPT_S) ? types::TY_LLVM_IR : types::TY_LLVM_BC;
Justin Lebar41094612016-01-11 23:07:27 +00002530 return C.MakeAction<BackendJobAction>(Input, Output);
Daniel Dunbar65229332009-03-13 11:38:42 +00002531 }
Justin Lebar41094612016-01-11 23:07:27 +00002532 return C.MakeAction<BackendJobAction>(Input, types::TY_PP_Asm);
Daniel Dunbar65229332009-03-13 11:38:42 +00002533 }
2534 case phases::Assemble:
Justin Lebar21e5d4f2016-01-14 21:41:27 +00002535 return C.MakeAction<AssembleJobAction>(std::move(Input), types::TY_Object);
Daniel Dunbar65229332009-03-13 11:38:42 +00002536 }
2537
David Blaikie83d382b2011-09-23 05:06:16 +00002538 llvm_unreachable("invalid phase in ConstructPhaseAction");
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00002539}
2540
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00002541void Driver::BuildJobs(Compilation &C) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00002542 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbare75d8342009-03-16 06:56:51 +00002543
2544 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
2545
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002546 // It is an error to provide a -o option if we are making multiple output
2547 // files.
Daniel Dunbare75d8342009-03-16 06:56:51 +00002548 if (FinalOutput) {
2549 unsigned NumOutputs = 0;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00002550 for (const Action *A : C.getActions())
2551 if (A->getType() != types::TY_Nothing)
Daniel Dunbare75d8342009-03-16 06:56:51 +00002552 ++NumOutputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002553
Daniel Dunbare75d8342009-03-16 06:56:51 +00002554 if (NumOutputs > 1) {
2555 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
Craig Topper92fc2df2014-05-17 16:56:41 +00002556 FinalOutput = nullptr;
Daniel Dunbare75d8342009-03-16 06:56:51 +00002557 }
2558 }
2559
Chad Rosier35767232013-04-30 22:01:21 +00002560 // Collect the list of architectures.
2561 llvm::StringSet<> ArchNames;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00002562 if (C.getDefaultToolChain().getTriple().isOSBinFormatMachO())
2563 for (const Arg *A : C.getArgs())
Chad Rosier35767232013-04-30 22:01:21 +00002564 if (A->getOption().matches(options::OPT_arch))
2565 ArchNames.insert(A->getValue());
Chad Rosier35767232013-04-30 22:01:21 +00002566
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002567 // Set of (Action, canonical ToolChain triple) pairs we've built jobs for.
2568 std::map<std::pair<const Action *, std::string>, InputInfo> CachedResults;
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00002569 for (Action *A : C.getActions()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002570 // If we are linking an image for multiple archs then the linker wants
2571 // -arch_multiple and -final_output <final image name>. Unfortunately, this
2572 // doesn't fit in cleanly because we have to pass this information down.
Daniel Dunbare75d8342009-03-16 06:56:51 +00002573 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002574 // FIXME: This is a hack; find a cleaner way to integrate this into the
2575 // process.
Craig Topper92fc2df2014-05-17 16:56:41 +00002576 const char *LinkingOutput = nullptr;
Daniel Dunbardd765242009-03-26 16:12:09 +00002577 if (isa<LipoJobAction>(A)) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00002578 if (FinalOutput)
Richard Smithbd55daf2012-11-01 04:30:05 +00002579 LinkingOutput = FinalOutput->getValue();
Daniel Dunbare75d8342009-03-16 06:56:51 +00002580 else
Hans Wennborga7707222015-01-09 17:38:53 +00002581 LinkingOutput = getDefaultImageName();
Daniel Dunbare75d8342009-03-16 06:56:51 +00002582 }
2583
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002584 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
Mehdi Aminic50b1a22016-10-07 21:27:26 +00002585 /*BoundArch*/ StringRef(),
Daniel Dunbare75d8342009-03-16 06:56:51 +00002586 /*AtTopLevel*/ true,
Chad Rosier35767232013-04-30 22:01:21 +00002587 /*MultipleArchs*/ ArchNames.size() > 1,
Samuel Antaod06239d2016-07-15 23:13:27 +00002588 /*LinkingOutput*/ LinkingOutput, CachedResults,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002589 /*TargetDeviceOffloadKind*/ Action::OFK_None);
Daniel Dunbare75d8342009-03-16 06:56:51 +00002590 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00002591
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002592 // If the user passed -Qunused-arguments or there were errors, don't warn
2593 // about any unused arguments.
Argyrios Kyrtzidis31448a42010-11-18 21:47:07 +00002594 if (Diags.hasErrorOccurred() ||
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00002595 C.getArgs().hasArg(options::OPT_Qunused_arguments))
Daniel Dunbard175d972009-03-18 18:03:46 +00002596 return;
2597
Daniel Dunbar58399ae2009-03-29 22:24:54 +00002598 // Claim -### here.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002599 (void)C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002600
Nico Weber47bf5052016-04-25 21:15:49 +00002601 // Claim --driver-mode, --rsp-quoting, it was handled earlier.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00002602 (void)C.getArgs().hasArg(options::OPT_driver_mode);
Nico Weber47bf5052016-04-25 21:15:49 +00002603 (void)C.getArgs().hasArg(options::OPT_rsp_quoting);
Hans Wennborg70850d82013-07-18 20:29:38 +00002604
Saleem Abdulrasool688b6bc2014-12-29 19:01:36 +00002605 for (Arg *A : C.getArgs()) {
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00002606 // FIXME: It would be nice to be able to send the argument to the
David Blaikie9c902b52011-09-25 23:23:43 +00002607 // DiagnosticsEngine, so that extra values, position, and so on could be
2608 // printed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00002609 if (!A->isClaimed()) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00002610 if (A->getOption().hasFlag(options::NoArgumentUnused))
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00002611 continue;
2612
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002613 // Suppress the warning automatically if this is just a flag, and it is an
2614 // instance of an argument we already claimed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00002615 const Option &Opt = A->getOption();
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00002616 if (Opt.getKind() == Option::FlagClass) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00002617 bool DuplicateClaimed = false;
2618
Sean Silva14facf32015-06-09 01:57:17 +00002619 for (const Arg *AA : C.getArgs().filtered(&Opt)) {
2620 if (AA->isClaimed()) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00002621 DuplicateClaimed = true;
2622 break;
2623 }
2624 }
2625
2626 if (DuplicateClaimed)
2627 continue;
2628 }
2629
Ehsan Akhgarid8518332016-01-25 21:14:52 +00002630 // In clang-cl, don't mention unknown arguments here since they have
2631 // already been warned about.
2632 if (!IsCLMode() || !A->getOption().matches(options::OPT_UNKNOWN))
2633 Diag(clang::diag::warn_drv_unused_argument)
2634 << A->getAsString(C.getArgs());
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00002635 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00002636 }
Daniel Dunbar95e6b192009-03-13 22:12:33 +00002637}
Daniel Dunbarc4343942010-02-03 03:07:56 +00002638
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002639namespace {
2640/// Utility class to control the collapse of dependent actions and select the
2641/// tools accordingly.
2642class ToolSelector final {
2643 /// The tool chain this selector refers to.
2644 const ToolChain &TC;
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00002645
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002646 /// The compilation this selector refers to.
2647 const Compilation &C;
Samuel Antaod06239d2016-07-15 23:13:27 +00002648
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002649 /// The base action this selector refers to.
2650 const JobAction *BaseAction;
Samuel Antaod06239d2016-07-15 23:13:27 +00002651
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002652 /// Set to true if the current toolchain refers to host actions.
2653 bool IsHostSelector;
Samuel Antaod06239d2016-07-15 23:13:27 +00002654
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002655 /// Set to true if save-temps and embed-bitcode functionalities are active.
2656 bool SaveTemps;
2657 bool EmbedBitcode;
2658
2659 /// Get previous dependent action or null if that does not exist. If
2660 /// \a CanBeCollapsed is false, that action must be legal to collapse or
2661 /// null will be returned.
2662 const JobAction *getPrevDependentAction(const ActionList &Inputs,
2663 ActionList &SavedOffloadAction,
2664 bool CanBeCollapsed = true) {
2665 // An option can be collapsed only if it has a single input.
2666 if (Inputs.size() != 1)
Craig Topper92fc2df2014-05-17 16:56:41 +00002667 return nullptr;
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002668
2669 Action *CurAction = *Inputs.begin();
2670 if (CanBeCollapsed &&
2671 !CurAction->isCollapsingWithNextDependentActionLegal())
2672 return nullptr;
2673
2674 // If the input action is an offload action. Look through it and save any
2675 // offload action that can be dropped in the event of a collapse.
2676 if (auto *OA = dyn_cast<OffloadAction>(CurAction)) {
2677 // If the dependent action is a device action, we will attempt to collapse
2678 // only with other device actions. Otherwise, we would do the same but
2679 // with host actions only.
2680 if (!IsHostSelector) {
2681 if (OA->hasSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)) {
2682 CurAction =
2683 OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true);
2684 if (CanBeCollapsed &&
2685 !CurAction->isCollapsingWithNextDependentActionLegal())
2686 return nullptr;
2687 SavedOffloadAction.push_back(OA);
2688 return dyn_cast<JobAction>(CurAction);
2689 }
2690 } else if (OA->hasHostDependence()) {
2691 CurAction = OA->getHostDependence();
2692 if (CanBeCollapsed &&
2693 !CurAction->isCollapsingWithNextDependentActionLegal())
2694 return nullptr;
2695 SavedOffloadAction.push_back(OA);
2696 return dyn_cast<JobAction>(CurAction);
2697 }
2698 return nullptr;
2699 }
2700
2701 return dyn_cast<JobAction>(CurAction);
2702 }
2703
2704 /// Return true if an assemble action can be collapsed.
2705 bool canCollapseAssembleAction() const {
2706 return TC.useIntegratedAs() && !SaveTemps &&
2707 !C.getArgs().hasArg(options::OPT_via_file_asm) &&
2708 !C.getArgs().hasArg(options::OPT__SLASH_FA) &&
2709 !C.getArgs().hasArg(options::OPT__SLASH_Fa);
2710 }
2711
2712 /// Return true if a preprocessor action can be collapsed.
2713 bool canCollapsePreprocessorAction() const {
2714 return !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
2715 !C.getArgs().hasArg(options::OPT_traditional_cpp) && !SaveTemps &&
2716 !C.getArgs().hasArg(options::OPT_rewrite_objc);
2717 }
2718
2719 /// Struct that relates an action with the offload actions that would be
2720 /// collapsed with it.
2721 struct JobActionInfo final {
2722 /// The action this info refers to.
2723 const JobAction *JA = nullptr;
2724 /// The offload actions we need to take care off if this action is
2725 /// collapsed.
2726 ActionList SavedOffloadAction;
2727 };
2728
2729 /// Append collapsed offload actions from the give nnumber of elements in the
2730 /// action info array.
2731 static void AppendCollapsedOffloadAction(ActionList &CollapsedOffloadAction,
2732 ArrayRef<JobActionInfo> &ActionInfo,
2733 unsigned ElementNum) {
2734 assert(ElementNum <= ActionInfo.size() && "Invalid number of elements.");
2735 for (unsigned I = 0; I < ElementNum; ++I)
2736 CollapsedOffloadAction.append(ActionInfo[I].SavedOffloadAction.begin(),
2737 ActionInfo[I].SavedOffloadAction.end());
2738 }
2739
2740 /// Functions that attempt to perform the combining. They detect if that is
2741 /// legal, and if so they update the inputs \a Inputs and the offload action
2742 /// that were collapsed in \a CollapsedOffloadAction. A tool that deals with
2743 /// the combined action is returned. If the combining is not legal or if the
2744 /// tool does not exist, null is returned.
2745 /// Currently three kinds of collapsing are supported:
2746 /// - Assemble + Backend + Compile;
2747 /// - Assemble + Backend ;
2748 /// - Backend + Compile.
2749 const Tool *
2750 combineAssembleBackendCompile(ArrayRef<JobActionInfo> ActionInfo,
2751 const ActionList *&Inputs,
2752 ActionList &CollapsedOffloadAction) {
2753 if (ActionInfo.size() < 3 || !canCollapseAssembleAction())
2754 return nullptr;
2755 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
2756 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
2757 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[2].JA);
2758 if (!AJ || !BJ || !CJ)
2759 return nullptr;
2760
2761 // Get compiler tool.
2762 const Tool *T = TC.SelectTool(*CJ);
2763 if (!T)
2764 return nullptr;
2765
Steven Wu574b0f22016-03-01 01:07:58 +00002766 // When using -fembed-bitcode, it is required to have the same tool (clang)
2767 // for both CompilerJA and BackendJA. Otherwise, combine two stages.
2768 if (EmbedBitcode) {
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002769 const Tool *BT = TC.SelectTool(*BJ);
2770 if (BT == T)
2771 return nullptr;
Steven Wu574b0f22016-03-01 01:07:58 +00002772 }
Bob Wilson23a55f12014-12-21 07:00:00 +00002773
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002774 if (!T->hasIntegratedAssembler())
Bob Wilson23a55f12014-12-21 07:00:00 +00002775 return nullptr;
Samuel Antaod06239d2016-07-15 23:13:27 +00002776
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002777 Inputs = &CJ->getInputs();
2778 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
2779 /*NumElements=*/3);
2780 return T;
2781 }
2782 const Tool *combineAssembleBackend(ArrayRef<JobActionInfo> ActionInfo,
2783 const ActionList *&Inputs,
2784 ActionList &CollapsedOffloadAction) {
2785 if (ActionInfo.size() < 2 || !canCollapseAssembleAction())
2786 return nullptr;
2787 auto *AJ = dyn_cast<AssembleJobAction>(ActionInfo[0].JA);
2788 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[1].JA);
2789 if (!AJ || !BJ)
2790 return nullptr;
2791
2792 // Retrieve the compile job, backend action must always be preceded by one.
2793 ActionList CompileJobOffloadActions;
2794 auto *CJ = getPrevDependentAction(BJ->getInputs(), CompileJobOffloadActions,
2795 /*CanBeCollapsed=*/false);
2796 if (!AJ || !BJ || !CJ)
2797 return nullptr;
2798
2799 assert(isa<CompileJobAction>(CJ) &&
2800 "Expecting compile job preceding backend job.");
2801
2802 // Get compiler tool.
2803 const Tool *T = TC.SelectTool(*CJ);
2804 if (!T)
2805 return nullptr;
2806
2807 if (!T->hasIntegratedAssembler())
2808 return nullptr;
2809
2810 Inputs = &BJ->getInputs();
2811 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
2812 /*NumElements=*/2);
2813 return T;
2814 }
2815 const Tool *combineBackendCompile(ArrayRef<JobActionInfo> ActionInfo,
2816 const ActionList *&Inputs,
2817 ActionList &CollapsedOffloadAction) {
2818 if (ActionInfo.size() < 2 || !canCollapsePreprocessorAction())
2819 return nullptr;
2820 auto *BJ = dyn_cast<BackendJobAction>(ActionInfo[0].JA);
2821 auto *CJ = dyn_cast<CompileJobAction>(ActionInfo[1].JA);
2822 if (!BJ || !CJ)
2823 return nullptr;
2824
2825 // Get compiler tool.
2826 const Tool *T = TC.SelectTool(*CJ);
2827 if (!T)
2828 return nullptr;
2829
2830 if (T->canEmitIR() && (SaveTemps || EmbedBitcode))
2831 return nullptr;
2832
2833 Inputs = &CJ->getInputs();
2834 AppendCollapsedOffloadAction(CollapsedOffloadAction, ActionInfo,
2835 /*NumElements=*/2);
2836 return T;
2837 }
2838
2839 /// Updates the inputs if the obtained tool supports combining with
2840 /// preprocessor action, and the current input is indeed a preprocessor
2841 /// action. If combining results in the collapse of offloading actions, those
2842 /// are appended to \a CollapsedOffloadAction.
2843 void combineWithPreprocessor(const Tool *T, const ActionList *&Inputs,
2844 ActionList &CollapsedOffloadAction) {
2845 if (!T || !canCollapsePreprocessorAction() || !T->hasIntegratedCPP())
2846 return;
2847
2848 // Attempt to get a preprocessor action dependence.
2849 ActionList PreprocessJobOffloadActions;
2850 auto *PJ = getPrevDependentAction(*Inputs, PreprocessJobOffloadActions);
2851 if (!PJ || !isa<PreprocessJobAction>(PJ))
2852 return;
2853
2854 // This is legal to combine. Append any offload action we found and set the
2855 // current inputs to preprocessor inputs.
2856 CollapsedOffloadAction.append(PreprocessJobOffloadActions.begin(),
2857 PreprocessJobOffloadActions.end());
2858 Inputs = &PJ->getInputs();
2859 }
2860
2861public:
2862 ToolSelector(const JobAction *BaseAction, const ToolChain &TC,
2863 const Compilation &C, bool SaveTemps, bool EmbedBitcode)
2864 : TC(TC), C(C), BaseAction(BaseAction), SaveTemps(SaveTemps),
2865 EmbedBitcode(EmbedBitcode) {
2866 assert(BaseAction && "Invalid base action.");
2867 IsHostSelector = BaseAction->getOffloadingDeviceKind() == Action::OFK_None;
2868 }
2869
2870 /// Check if a chain of actions can be combined and return the tool that can
2871 /// handle the combination of actions. The pointer to the current inputs \a
2872 /// Inputs and the list of offload actions \a CollapsedOffloadActions
2873 /// connected to collapsed actions are updated accordingly. The latter enables
2874 /// the caller of the selector to process them afterwards instead of just
2875 /// dropping them. If no suitable tool is found, null will be returned.
2876 const Tool *getTool(const ActionList *&Inputs,
2877 ActionList &CollapsedOffloadAction) {
2878 //
2879 // Get the largest chain of actions that we could combine.
2880 //
2881
2882 SmallVector<JobActionInfo, 5> ActionChain(1);
2883 ActionChain.back().JA = BaseAction;
2884 while (ActionChain.back().JA) {
2885 const Action *CurAction = ActionChain.back().JA;
2886
2887 // Grow the chain by one element.
2888 ActionChain.resize(ActionChain.size() + 1);
2889 JobActionInfo &AI = ActionChain.back();
2890
2891 // Attempt to fill it with the
2892 AI.JA =
2893 getPrevDependentAction(CurAction->getInputs(), AI.SavedOffloadAction);
Daniel Dunbarc4343942010-02-03 03:07:56 +00002894 }
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002895
2896 // Pop the last action info as it could not be filled.
2897 ActionChain.pop_back();
2898
2899 //
2900 // Attempt to combine actions. If all combining attempts failed, just return
2901 // the tool of the provided action. At the end we attempt to combine the
2902 // action with any preprocessor action it may depend on.
2903 //
2904
2905 const Tool *T = combineAssembleBackendCompile(ActionChain, Inputs,
2906 CollapsedOffloadAction);
2907 if (!T)
2908 T = combineAssembleBackend(ActionChain, Inputs, CollapsedOffloadAction);
2909 if (!T)
2910 T = combineBackendCompile(ActionChain, Inputs, CollapsedOffloadAction);
2911 if (!T) {
2912 Inputs = &BaseAction->getInputs();
2913 T = TC.SelectTool(*BaseAction);
2914 }
2915
2916 combineWithPreprocessor(T, Inputs, CollapsedOffloadAction);
2917 return T;
Daniel Dunbarc4343942010-02-03 03:07:56 +00002918 }
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002919};
Daniel Dunbarc4343942010-02-03 03:07:56 +00002920}
2921
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002922/// Return a string that uniquely identifies the result of a job. The bound arch
2923/// is not necessarily represented in the toolchain's triple -- for example,
2924/// armv7 and armv7s both map to the same triple -- so we need both in our map.
2925/// Also, we need to add the offloading device kind, as the same tool chain can
2926/// be used for host and device for some programming models, e.g. OpenMP.
2927static std::string GetTriplePlusArchString(const ToolChain *TC,
2928 StringRef BoundArch,
2929 Action::OffloadKind OffloadKind) {
Justin Lebar55c83322016-01-16 03:30:08 +00002930 std::string TriplePlusArch = TC->getTriple().normalize();
Mehdi Aminic50b1a22016-10-07 21:27:26 +00002931 if (!BoundArch.empty()) {
Justin Lebar55c83322016-01-16 03:30:08 +00002932 TriplePlusArch += "-";
2933 TriplePlusArch += BoundArch;
2934 }
Samuel Antao59efaed2016-10-27 17:31:22 +00002935 TriplePlusArch += "-";
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002936 TriplePlusArch += Action::GetOffloadKindName(OffloadKind);
2937 return TriplePlusArch;
2938}
2939
2940InputInfo Driver::BuildJobsForAction(
2941 Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
2942 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
2943 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
2944 Action::OffloadKind TargetDeviceOffloadKind) const {
2945 std::pair<const Action *, std::string> ActionTC = {
2946 A, GetTriplePlusArchString(TC, BoundArch, TargetDeviceOffloadKind)};
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002947 auto CachedResult = CachedResults.find(ActionTC);
2948 if (CachedResult != CachedResults.end()) {
2949 return CachedResult->second;
2950 }
Samuel Antaod06239d2016-07-15 23:13:27 +00002951 InputInfo Result = BuildJobsForActionNoCache(
2952 C, A, TC, BoundArch, AtTopLevel, MultipleArchs, LinkingOutput,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002953 CachedResults, TargetDeviceOffloadKind);
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002954 CachedResults[ActionTC] = Result;
2955 return Result;
2956}
2957
2958InputInfo Driver::BuildJobsForActionNoCache(
Mehdi Aminic50b1a22016-10-07 21:27:26 +00002959 Compilation &C, const Action *A, const ToolChain *TC, StringRef BoundArch,
Justin Lebarb44f6fe2016-01-14 21:41:21 +00002960 bool AtTopLevel, bool MultipleArchs, const char *LinkingOutput,
Samuel Antaod06239d2016-07-15 23:13:27 +00002961 std::map<std::pair<const Action *, std::string>, InputInfo> &CachedResults,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002962 Action::OffloadKind TargetDeviceOffloadKind) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00002963 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbarc4acf9d2009-03-18 23:18:19 +00002964
Samuel Antaod06239d2016-07-15 23:13:27 +00002965 InputInfoList OffloadDependencesInputInfo;
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002966 bool BuildingForOffloadDevice = TargetDeviceOffloadKind != Action::OFK_None;
Samuel Antaod06239d2016-07-15 23:13:27 +00002967 if (const OffloadAction *OA = dyn_cast<OffloadAction>(A)) {
2968 // The offload action is expected to be used in four different situations.
2969 //
2970 // a) Set a toolchain/architecture/kind for a host action:
2971 // Host Action 1 -> OffloadAction -> Host Action 2
2972 //
2973 // b) Set a toolchain/architecture/kind for a device action;
2974 // Device Action 1 -> OffloadAction -> Device Action 2
2975 //
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00002976 // c) Specify a device dependence to a host action;
Samuel Antaod06239d2016-07-15 23:13:27 +00002977 // Device Action 1 _
2978 // \
2979 // Host Action 1 ---> OffloadAction -> Host Action 2
2980 //
2981 // d) Specify a host dependence to a device action.
2982 // Host Action 1 _
2983 // \
2984 // Device Action 1 ---> OffloadAction -> Device Action 2
2985 //
2986 // For a) and b), we just return the job generated for the dependence. For
2987 // c) and d) we override the current action with the host/device dependence
2988 // if the current toolchain is host/device and set the offload dependences
2989 // info with the jobs obtained from the device/host dependence(s).
2990
2991 // If there is a single device option, just generate the job for it.
2992 if (OA->hasSingleDeviceDependence()) {
2993 InputInfo DevA;
2994 OA->doOnEachDeviceDependence([&](Action *DepA, const ToolChain *DepTC,
2995 const char *DepBoundArch) {
2996 DevA =
2997 BuildJobsForAction(C, DepA, DepTC, DepBoundArch, AtTopLevel,
2998 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00002999 CachedResults, DepA->getOffloadingDeviceKind());
Samuel Antaod06239d2016-07-15 23:13:27 +00003000 });
3001 return DevA;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003002 }
Samuel Antaod06239d2016-07-15 23:13:27 +00003003
3004 // If 'Action 2' is host, we generate jobs for the device dependences and
3005 // override the current action with the host dependence. Otherwise, we
3006 // generate the host dependences and override the action with the device
3007 // dependence. The dependences can't therefore be a top-level action.
3008 OA->doOnEachDependence(
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003009 /*IsHostDependence=*/BuildingForOffloadDevice,
Samuel Antaod06239d2016-07-15 23:13:27 +00003010 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
3011 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
3012 C, DepA, DepTC, DepBoundArch, /*AtTopLevel=*/false,
3013 /*MultipleArchs*/ !!DepBoundArch, LinkingOutput, CachedResults,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003014 DepA->getOffloadingDeviceKind()));
Samuel Antaod06239d2016-07-15 23:13:27 +00003015 });
3016
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003017 A = BuildingForOffloadDevice
Samuel Antaod06239d2016-07-15 23:13:27 +00003018 ? OA->getSingleDeviceDependence(/*DoNotConsiderHostActions=*/true)
3019 : OA->getHostDependence();
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003020 }
3021
Daniel Dunbare75d8342009-03-16 06:56:51 +00003022 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00003023 // FIXME: It would be nice to not claim this here; maybe the old scheme of
3024 // just using Args was better?
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00003025 const Arg &Input = IA->getInputArg();
3026 Input.claim();
Daniel Dunbar35cbfeb2010-06-09 22:31:08 +00003027 if (Input.getOption().matches(options::OPT_INPUT)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00003028 const char *Name = Input.getValue();
Justin Lebard98cea82016-01-11 23:15:21 +00003029 return InputInfo(A, Name, /* BaseInput = */ Name);
Douglas Katzman678d0cb2015-06-16 18:01:24 +00003030 }
Justin Lebard98cea82016-01-11 23:15:21 +00003031 return InputInfo(A, &Input, /* BaseInput = */ "");
Daniel Dunbare75d8342009-03-16 06:56:51 +00003032 }
3033
3034 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
Chad Rosiera78a6eb2012-04-27 16:50:38 +00003035 const ToolChain *TC;
Mehdi Aminic50b1a22016-10-07 21:27:26 +00003036 StringRef ArchName = BAA->getArchName();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00003037
Mehdi Aminic50b1a22016-10-07 21:27:26 +00003038 if (!ArchName.empty())
Andrey Turetskiy6a8b91d2016-04-21 10:16:48 +00003039 TC = &getToolChain(C.getArgs(),
3040 computeTargetTriple(*this, DefaultTargetTriple,
3041 C.getArgs(), ArchName));
Chad Rosiera78a6eb2012-04-27 16:50:38 +00003042 else
3043 TC = &C.getDefaultToolChain();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00003044
Nico Weber5a459f82016-02-23 19:30:43 +00003045 return BuildJobsForAction(C, *BAA->input_begin(), TC, ArchName, AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00003046 MultipleArchs, LinkingOutput, CachedResults,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003047 TargetDeviceOffloadKind);
Daniel Dunbare75d8342009-03-16 06:56:51 +00003048 }
3049
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003050
Daniel Dunbare75d8342009-03-16 06:56:51 +00003051 const ActionList *Inputs = &A->getInputs();
Daniel Dunbarc4343942010-02-03 03:07:56 +00003052
3053 const JobAction *JA = cast<JobAction>(A);
Samuel Antaod06239d2016-07-15 23:13:27 +00003054 ActionList CollapsedOffloadActions;
3055
Steven Wu844ab6a2016-11-16 06:06:44 +00003056 ToolSelector TS(JA, *TC, C, isSaveTempsEnabled(), embedBitcodeInObject());
Samuel Antao9c9d9cd2016-10-27 16:29:20 +00003057 const Tool *T = TS.getTool(Inputs, CollapsedOffloadActions);
3058
Rafael Espindola79764462013-03-24 15:06:53 +00003059 if (!T)
Justin Lebar9eaa4892016-01-11 23:09:32 +00003060 return InputInfo();
Daniel Dunbare75d8342009-03-16 06:56:51 +00003061
Samuel Antaod06239d2016-07-15 23:13:27 +00003062 // If we've collapsed action list that contained OffloadAction we
3063 // need to build jobs for host/device-side inputs it may have held.
3064 for (const auto *OA : CollapsedOffloadActions)
3065 cast<OffloadAction>(OA)->doOnEachDependence(
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003066 /*IsHostDependence=*/BuildingForOffloadDevice,
Samuel Antaod06239d2016-07-15 23:13:27 +00003067 [&](Action *DepA, const ToolChain *DepTC, const char *DepBoundArch) {
3068 OffloadDependencesInputInfo.push_back(BuildJobsForAction(
Artem Belevichbee2f412016-08-22 18:50:34 +00003069 C, DepA, DepTC, DepBoundArch, /* AtTopLevel */ false,
Samuel Antaod06239d2016-07-15 23:13:27 +00003070 /*MultipleArchs=*/!!DepBoundArch, LinkingOutput, CachedResults,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003071 DepA->getOffloadingDeviceKind()));
Samuel Antaod06239d2016-07-15 23:13:27 +00003072 });
Artem Belevichf8144ab2015-08-27 18:10:41 +00003073
Daniel Dunbare75d8342009-03-16 06:56:51 +00003074 // Only use pipes when there is exactly one input.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00003075 InputInfoList InputInfos;
Saleem Abdulrasoolda3f4e52014-12-29 21:02:47 +00003076 for (const Action *Input : *Inputs) {
Eric Christopher14668dd2013-02-18 00:38:25 +00003077 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
3078 // shouldn't get temporary output names.
Daniel Dunbar6beaf512010-06-04 18:28:41 +00003079 // FIXME: Clean this up.
Justin Lebar9eaa4892016-01-11 23:09:32 +00003080 bool SubJobAtTopLevel =
3081 AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A));
Samuel Antaod06239d2016-07-15 23:13:27 +00003082 InputInfos.push_back(BuildJobsForAction(
3083 C, Input, TC, BoundArch, SubJobAtTopLevel, MultipleArchs, LinkingOutput,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003084 CachedResults, A->getOffloadingDeviceKind()));
Daniel Dunbare75d8342009-03-16 06:56:51 +00003085 }
3086
Daniel Dunbare75d8342009-03-16 06:56:51 +00003087 // Always use the first input as the base input.
3088 const char *BaseInput = InputInfos[0].getBaseInput();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003089
Daniel Dunbar6beaf512010-06-04 18:28:41 +00003090 // ... except dsymutil actions, which use their actual input as the base
3091 // input.
3092 if (JA->getType() == types::TY_dSYM)
3093 BaseInput = InputInfos[0].getFilename();
3094
Samuel Antaod06239d2016-07-15 23:13:27 +00003095 // Append outputs of offload device jobs to the input list
3096 if (!OffloadDependencesInputInfo.empty())
3097 InputInfos.append(OffloadDependencesInputInfo.begin(),
3098 OffloadDependencesInputInfo.end());
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003099
Vedant Kumar18286cf2016-07-27 23:02:20 +00003100 // Set the effective triple of the toolchain for the duration of this job.
3101 llvm::Triple EffectiveTriple;
3102 const ToolChain &ToolTC = T->getToolChain();
Samuel Antao31fef982016-10-27 17:39:44 +00003103 const ArgList &Args =
3104 C.getArgsForToolChain(TC, BoundArch, A->getOffloadingDeviceKind());
Vedant Kumar18286cf2016-07-27 23:02:20 +00003105 if (InputInfos.size() != 1) {
3106 EffectiveTriple = llvm::Triple(ToolTC.ComputeEffectiveClangTriple(Args));
3107 } else {
3108 // Pass along the input type if it can be unambiguously determined.
3109 EffectiveTriple = llvm::Triple(
3110 ToolTC.ComputeEffectiveClangTriple(Args, InputInfos[0].getType()));
3111 }
3112 RegisterEffectiveTriple TripleRAII(ToolTC, EffectiveTriple);
3113
Daniel Dunbard00272f2010-08-02 02:38:15 +00003114 // Determine the place to write output to, if any.
Justin Lebar9eaa4892016-01-11 23:09:32 +00003115 InputInfo Result;
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003116 InputInfoList UnbundlingResults;
3117 if (auto *UA = dyn_cast<OffloadUnbundlingJobAction>(JA)) {
3118 // If we have an unbundling job, we need to create results for all the
3119 // outputs. We also update the results cache so that other actions using
3120 // this unbundling action can get the right results.
3121 for (auto &UI : UA->getDependentActionsInfo()) {
3122 assert(UI.DependentOffloadKind != Action::OFK_None &&
3123 "Unbundling with no offloading??");
3124
3125 // Unbundling actions are never at the top level. When we generate the
3126 // offloading prefix, we also do that for the host file because the
3127 // unbundling action does not change the type of the output which can
3128 // cause a overwrite.
3129 std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
3130 UI.DependentOffloadKind,
3131 UI.DependentToolChain->getTriple().normalize(),
3132 /*CreatePrefixForHost=*/true);
3133 auto CurI = InputInfo(
3134 UA, GetNamedOutputPath(C, *UA, BaseInput, UI.DependentBoundArch,
3135 /*AtTopLevel=*/false, MultipleArchs,
3136 OffloadingPrefix),
3137 BaseInput);
3138 // Save the unbundling result.
3139 UnbundlingResults.push_back(CurI);
3140
3141 // Get the unique string identifier for this dependence and cache the
3142 // result.
3143 CachedResults[{A, GetTriplePlusArchString(
3144 UI.DependentToolChain, UI.DependentBoundArch,
3145 UI.DependentOffloadKind)}] = CurI;
3146 }
3147
3148 // Now that we have all the results generated, select the one that should be
3149 // returned for the current depending action.
3150 std::pair<const Action *, std::string> ActionTC = {
3151 A, GetTriplePlusArchString(TC, BoundArch, TargetDeviceOffloadKind)};
3152 assert(CachedResults.find(ActionTC) != CachedResults.end() &&
3153 "Result does not exist??");
3154 Result = CachedResults[ActionTC];
3155 } else if (JA->getType() == types::TY_Nothing)
Justin Lebard98cea82016-01-11 23:15:21 +00003156 Result = InputInfo(A, BaseInput);
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003157 else {
3158 // We only have to generate a prefix for the host if this is not a top-level
3159 // action.
3160 std::string OffloadingPrefix = Action::GetOffloadingFileNamePrefix(
3161 A->getOffloadingDeviceKind(), TC->getTriple().normalize(),
3162 /*CreatePrefixForHost=*/!!A->getOffloadingHostActiveKinds() &&
3163 !AtTopLevel);
Justin Lebard98cea82016-01-11 23:15:21 +00003164 Result = InputInfo(A, GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
Samuel Antaod06239d2016-07-15 23:13:27 +00003165 AtTopLevel, MultipleArchs,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003166 OffloadingPrefix),
Justin Lebard98cea82016-01-11 23:15:21 +00003167 BaseInput);
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003168 }
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003169
Chad Rosierbe10f982011-08-02 17:58:04 +00003170 if (CCCPrintBindings && !CCGenDiagnostics) {
Rafael Espindola79764462013-03-24 15:06:53 +00003171 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
3172 << " - \"" << T->getName() << "\", inputs: [";
Daniel Dunbarb39cc522009-03-17 22:47:06 +00003173 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
3174 llvm::errs() << InputInfos[i].getAsString();
3175 if (i + 1 != e)
3176 llvm::errs() << ", ";
3177 }
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003178 if (UnbundlingResults.empty())
3179 llvm::errs() << "], output: " << Result.getAsString() << "\n";
3180 else {
3181 llvm::errs() << "], outputs: [";
3182 for (unsigned i = 0, e = UnbundlingResults.size(); i != e; ++i) {
3183 llvm::errs() << UnbundlingResults[i].getAsString();
3184 if (i + 1 != e)
3185 llvm::errs() << ", ";
3186 }
3187 llvm::errs() << "] \n";
3188 }
Daniel Dunbarb39cc522009-03-17 22:47:06 +00003189 } else {
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003190 if (UnbundlingResults.empty())
3191 T->ConstructJob(
3192 C, *JA, Result, InputInfos,
3193 C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()),
3194 LinkingOutput);
3195 else
Samuel Antao7108bf32016-11-03 15:41:50 +00003196 T->ConstructJobMultipleOutputs(
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003197 C, *JA, UnbundlingResults, InputInfos,
3198 C.getArgsForToolChain(TC, BoundArch, JA->getOffloadingDeviceKind()),
3199 LinkingOutput);
Daniel Dunbarb39cc522009-03-17 22:47:06 +00003200 }
Justin Lebar9eaa4892016-01-11 23:09:32 +00003201 return Result;
Daniel Dunbare75d8342009-03-16 06:56:51 +00003202}
3203
Hans Wennborga7707222015-01-09 17:38:53 +00003204const char *Driver::getDefaultImageName() const {
3205 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
3206 return Target.isOSWindows() ? "a.exe" : "a.out";
3207}
3208
Hans Wennborg2c21f742013-10-17 16:16:23 +00003209/// \brief Create output filename based on ArgValue, which could either be a
3210/// full filename, filename without extension, or a directory. If ArgValue
3211/// does not provide a filename, then use BaseName, and use the extension
3212/// suitable for FileType.
Hans Wennborg207fcf02013-08-12 21:56:42 +00003213static const char *MakeCLOutputFilename(const ArgList &Args, StringRef ArgValue,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003214 StringRef BaseName,
3215 types::ID FileType) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00003216 SmallString<128> Filename = ArgValue;
Justin Bogner5aaf2e72014-06-26 20:59:36 +00003217
Hans Wennborgf1a74252013-09-10 20:18:04 +00003218 if (ArgValue.empty()) {
3219 // If the argument is empty, output to BaseName in the current dir.
3220 Filename = BaseName;
3221 } else if (llvm::sys::path::is_separator(Filename.back())) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00003222 // If the argument is a directory, output to BaseName in that dir.
3223 llvm::sys::path::append(Filename, BaseName);
3224 }
3225
3226 if (!llvm::sys::path::has_extension(ArgValue)) {
3227 // If the argument didn't provide an extension, then set it.
3228 const char *Extension = types::getTypeTempSuffix(FileType, true);
Hans Wennborgf1a74252013-09-10 20:18:04 +00003229
3230 if (FileType == types::TY_Image &&
3231 Args.hasArg(options::OPT__SLASH_LD, options::OPT__SLASH_LDd)) {
3232 // The output file is a dll.
3233 Extension = "dll";
3234 }
3235
Hans Wennborg207fcf02013-08-12 21:56:42 +00003236 llvm::sys::path::replace_extension(Filename, Extension);
3237 }
3238
3239 return Args.MakeArgString(Filename.c_str());
3240}
3241
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003242const char *Driver::GetNamedOutputPath(Compilation &C, const JobAction &JA,
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003243 const char *BaseInput,
Mehdi Aminic50b1a22016-10-07 21:27:26 +00003244 StringRef BoundArch, bool AtTopLevel,
Samuel Antaod06239d2016-07-15 23:13:27 +00003245 bool MultipleArchs,
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003246 StringRef OffloadingPrefix) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00003247 llvm::PrettyStackTraceString CrashInfo("Computing output path");
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003248 // Output to a user requested destination?
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003249 if (AtTopLevel && !isa<DsymutilJobAction>(JA) && !isa<VerifyJobAction>(JA)) {
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003250 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
Chad Rosier633dcdc2013-01-24 19:14:47 +00003251 return C.addResultFile(FinalOutput->getValue(), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003252 }
3253
Hans Wennborge0053472013-12-20 18:40:46 +00003254 // For /P, preprocess to file named after BaseInput.
3255 if (C.getArgs().hasArg(options::OPT__SLASH_P)) {
3256 assert(AtTopLevel && isa<PreprocessJobAction>(JA));
3257 StringRef BaseName = llvm::sys::path::filename(BaseInput);
Hans Wennborg04c764f2014-06-17 00:19:12 +00003258 StringRef NameArg;
Greg Bedwell065f70a2015-06-09 10:24:06 +00003259 if (Arg *A = C.getArgs().getLastArg(options::OPT__SLASH_Fi))
Hans Wennborg04c764f2014-06-17 00:19:12 +00003260 NameArg = A->getValue();
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003261 return C.addResultFile(
3262 MakeCLOutputFilename(C.getArgs(), NameArg, BaseName, types::TY_PP_C),
3263 &JA);
Hans Wennborge0053472013-12-20 18:40:46 +00003264 }
3265
Nick Lewycky6e1ce292010-09-24 00:46:53 +00003266 // Default to writing to stdout?
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00003267 if (AtTopLevel && !CCGenDiagnostics &&
3268 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
Nick Lewycky6e1ce292010-09-24 00:46:53 +00003269 return "-";
3270
Hans Wennborg2c21f742013-10-17 16:16:23 +00003271 // Is this the assembly listing for /FA?
3272 if (JA.getType() == types::TY_PP_Asm &&
3273 (C.getArgs().hasArg(options::OPT__SLASH_FA) ||
3274 C.getArgs().hasArg(options::OPT__SLASH_Fa))) {
3275 // Use /Fa and the input filename to determine the asm file name.
3276 StringRef BaseName = llvm::sys::path::filename(BaseInput);
3277 StringRef FaValue = C.getArgs().getLastArgValue(options::OPT__SLASH_Fa);
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003278 return C.addResultFile(
3279 MakeCLOutputFilename(C.getArgs(), FaValue, BaseName, JA.getType()),
3280 &JA);
Hans Wennborg2c21f742013-10-17 16:16:23 +00003281 }
3282
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003283 // Output to a temporary file?
Reid Kleckner68eb60b2015-02-02 22:41:48 +00003284 if ((!AtTopLevel && !isSaveTempsEnabled() &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003285 !C.getArgs().hasArg(options::OPT__SLASH_Fo)) ||
Chad Rosierbe10f982011-08-02 17:58:04 +00003286 CCGenDiagnostics) {
Chad Rosier97c37372011-08-26 22:27:02 +00003287 StringRef Name = llvm::sys::path::filename(BaseInput);
3288 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003289 std::string TmpName = GetTemporaryPath(
3290 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Malcolm Parsonsf76f6502016-11-02 10:39:27 +00003291 return C.addTempFile(C.getArgs().MakeArgString(TmpName));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003292 }
3293
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00003294 SmallString<128> BasePath(BaseInput);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00003295 StringRef BaseName;
Daniel Dunbar67fea712011-03-25 18:16:51 +00003296
3297 // Dsymutil actions should use the full path.
Eric Christopher551ef452011-08-23 17:56:55 +00003298 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
Daniel Dunbar67fea712011-03-25 18:16:51 +00003299 BaseName = BasePath;
3300 else
3301 BaseName = llvm::sys::path::filename(BasePath);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003302
3303 // Determine what the derived output name should be.
3304 const char *NamedOutput;
Hans Wennborg2b89a262013-08-06 22:11:28 +00003305
Hans Wennborg625fba82016-10-04 21:01:04 +00003306 if ((JA.getType() == types::TY_Object || JA.getType() == types::TY_LTO_BC) &&
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00003307 C.getArgs().hasArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)) {
3308 // The /Fo or /o flag decides the object filename.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003309 StringRef Val =
3310 C.getArgs()
3311 .getLastArg(options::OPT__SLASH_Fo, options::OPT__SLASH_o)
3312 ->getValue();
3313 NamedOutput =
3314 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Object);
Hans Wennborg207fcf02013-08-12 21:56:42 +00003315 } else if (JA.getType() == types::TY_Image &&
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003316 C.getArgs().hasArg(options::OPT__SLASH_Fe,
3317 options::OPT__SLASH_o)) {
Ehsan Akhgari81f36b72014-09-11 18:16:21 +00003318 // The /Fe or /o flag names the linked file.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003319 StringRef Val =
3320 C.getArgs()
3321 .getLastArg(options::OPT__SLASH_Fe, options::OPT__SLASH_o)
3322 ->getValue();
3323 NamedOutput =
3324 MakeCLOutputFilename(C.getArgs(), Val, BaseName, types::TY_Image);
Hans Wennborgf1a74252013-09-10 20:18:04 +00003325 } else if (JA.getType() == types::TY_Image) {
Hans Wennborg207fcf02013-08-12 21:56:42 +00003326 if (IsCLMode()) {
3327 // clang-cl uses BaseName for the executable name.
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003328 NamedOutput =
3329 MakeCLOutputFilename(C.getArgs(), "", BaseName, types::TY_Image);
Samuel Antao59efaed2016-10-27 17:31:22 +00003330 } else {
Hans Wennborga7707222015-01-09 17:38:53 +00003331 SmallString<128> Output(getDefaultImageName());
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003332 Output += OffloadingPrefix;
Samuel Antao59efaed2016-10-27 17:31:22 +00003333 if (MultipleArchs && !BoundArch.empty()) {
3334 Output += "-";
3335 Output.append(BoundArch);
3336 }
Chad Rosier35767232013-04-30 22:01:21 +00003337 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
Nico Weber2ca4be92016-03-01 23:16:44 +00003338 }
3339 } else if (JA.getType() == types::TY_PCH && IsCLMode()) {
Malcolm Parsonsf76f6502016-11-02 10:39:27 +00003340 NamedOutput = C.getArgs().MakeArgString(GetClPchPath(C, BaseName));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003341 } else {
Hans Wennborg0a096a02013-09-05 17:05:56 +00003342 const char *Suffix = types::getTypeTempSuffix(JA.getType(), IsCLMode());
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003343 assert(Suffix && "All types used for output should have a suffix.");
3344
3345 std::string::size_type End = std::string::npos;
3346 if (!types::appendSuffixForType(JA.getType()))
3347 End = BaseName.rfind('.');
Chad Rosier35767232013-04-30 22:01:21 +00003348 SmallString<128> Suffixed(BaseName.substr(0, End));
Samuel Antao3b7e38b2016-10-27 18:14:55 +00003349 Suffixed += OffloadingPrefix;
Mehdi Aminic50b1a22016-10-07 21:27:26 +00003350 if (MultipleArchs && !BoundArch.empty()) {
Chad Rosier35767232013-04-30 22:01:21 +00003351 Suffixed += "-";
3352 Suffixed.append(BoundArch);
3353 }
Bob Wilson23a55f12014-12-21 07:00:00 +00003354 // When using both -save-temps and -emit-llvm, use a ".tmp.bc" suffix for
3355 // the unoptimized bitcode so that it does not get overwritten by the ".bc"
3356 // optimized bitcode output.
3357 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_emit_llvm) &&
3358 JA.getType() == types::TY_LLVM_BC)
3359 Suffixed += ".tmp";
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003360 Suffixed += '.';
3361 Suffixed += Suffix;
3362 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
3363 }
3364
Reid Kleckner68eb60b2015-02-02 22:41:48 +00003365 // Prepend object file path if -save-temps=obj
3366 if (!AtTopLevel && isSaveTempsObj() && C.getArgs().hasArg(options::OPT_o) &&
3367 JA.getType() != types::TY_PCH) {
3368 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
3369 SmallString<128> TempPath(FinalOutput->getValue());
3370 llvm::sys::path::remove_filename(TempPath);
3371 StringRef OutputFileName = llvm::sys::path::filename(NamedOutput);
3372 llvm::sys::path::append(TempPath, OutputFileName);
3373 NamedOutput = C.getArgs().MakeArgString(TempPath.c_str());
3374 }
3375
Chad Rosier62135492012-07-09 17:31:28 +00003376 // If we're saving temps and the temp file conflicts with the input file,
Chad Rosier5b58af02012-04-20 20:05:08 +00003377 // then avoid overwriting input file.
Reid Kleckner68eb60b2015-02-02 22:41:48 +00003378 if (!AtTopLevel && isSaveTempsEnabled() && NamedOutput == BaseName) {
Chad Rosier5b58af02012-04-20 20:05:08 +00003379 bool SameFile = false;
3380 SmallString<256> Result;
3381 llvm::sys::fs::current_path(Result);
3382 llvm::sys::path::append(Result, BaseName);
3383 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
3384 // Must share the same path to conflict.
3385 if (SameFile) {
3386 StringRef Name = llvm::sys::path::filename(BaseInput);
3387 std::pair<StringRef, StringRef> Split = Name.split('.');
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003388 std::string TmpName = GetTemporaryPath(
3389 Split.first, types::getTypeTempSuffix(JA.getType(), IsCLMode()));
Malcolm Parsonsf76f6502016-11-02 10:39:27 +00003390 return C.addTempFile(C.getArgs().MakeArgString(TmpName));
Chad Rosier5b58af02012-04-20 20:05:08 +00003391 }
Chad Rosierf8412cd2011-07-15 21:54:29 +00003392 }
3393
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00003394 // As an annoying special case, PCH generation doesn't strip the pathname.
Nico Weber8ab92192016-03-02 23:29:29 +00003395 if (JA.getType() == types::TY_PCH && !IsCLMode()) {
Michael J. Spencere1696752010-12-18 00:19:12 +00003396 llvm::sys::path::remove_filename(BasePath);
3397 if (BasePath.empty())
Daniel Dunbare6c83192009-03-18 09:58:30 +00003398 BasePath = NamedOutput;
3399 else
Michael J. Spencere1696752010-12-18 00:19:12 +00003400 llvm::sys::path::append(BasePath, NamedOutput);
Chad Rosier633dcdc2013-01-24 19:14:47 +00003401 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003402 } else {
Chad Rosier633dcdc2013-01-24 19:14:47 +00003403 return C.addResultFile(NamedOutput, &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00003404 }
3405}
3406
Mehdi Amini12011172016-10-06 05:11:48 +00003407std::string Driver::GetFilePath(StringRef Name, const ToolChain &TC) const {
Chandler Carruth84559242010-03-22 01:52:07 +00003408 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00003409 // attempting to use this prefix when looking for file paths.
Douglas Katzman26eabf62015-06-24 15:10:30 +00003410 for (const std::string &Dir : PrefixDirs) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00003411 if (Dir.empty())
3412 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00003413 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00003414 llvm::sys::path::append(P, Name);
3415 if (llvm::sys::fs::exists(Twine(P)))
Chandler Carruth84559242010-03-22 01:52:07 +00003416 return P.str();
3417 }
3418
Rafael Espindola609a6642013-06-24 18:33:43 +00003419 SmallString<128> P(ResourceDir);
3420 llvm::sys::path::append(P, Name);
3421 if (llvm::sys::fs::exists(Twine(P)))
Peter Collingbournefa9771f2011-09-06 02:08:31 +00003422 return P.str();
3423
Douglas Katzman26eabf62015-06-24 15:10:30 +00003424 for (const std::string &Dir : TC.getFilePaths()) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00003425 if (Dir.empty())
3426 continue;
Douglas Katzman26eabf62015-06-24 15:10:30 +00003427 SmallString<128> P(Dir[0] == '=' ? SysRoot + Dir.substr(1) : Dir);
Rafael Espindola609a6642013-06-24 18:33:43 +00003428 llvm::sys::path::append(P, Name);
3429 if (llvm::sys::fs::exists(Twine(P)))
Daniel Dunbar1ce81532009-09-09 22:33:00 +00003430 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00003431 }
3432
Daniel Dunbar1ce81532009-09-09 22:33:00 +00003433 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00003434}
3435
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003436void Driver::generatePrefixedToolNames(
Mehdi Amini12011172016-10-06 05:11:48 +00003437 StringRef Tool, const ToolChain &TC,
Douglas Katzmana67e50c2015-06-26 15:47:46 +00003438 SmallVectorImpl<std::string> &Names) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003439 // FIXME: Needs a better variable than DefaultTargetTriple
Mehdi Amini12011172016-10-06 05:11:48 +00003440 Names.emplace_back((DefaultTargetTriple + "-" + Tool).str());
Benjamin Kramer3204b152015-05-29 19:42:19 +00003441 Names.emplace_back(Tool);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00003442
3443 // Allow the discovery of tools prefixed with LLVM's default target triple.
3444 std::string LLVMDefaultTargetTriple = llvm::sys::getDefaultTargetTriple();
3445 if (LLVMDefaultTargetTriple != DefaultTargetTriple)
Mehdi Amini12011172016-10-06 05:11:48 +00003446 Names.emplace_back((LLVMDefaultTargetTriple + "-" + Tool).str());
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003447}
3448
Benjamin Kramer7111b912014-11-04 20:26:01 +00003449static bool ScanDirForExecutable(SmallString<128> &Dir,
3450 ArrayRef<std::string> Names) {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003451 for (const auto &Name : Names) {
3452 llvm::sys::path::append(Dir, Name);
3453 if (llvm::sys::fs::can_execute(Twine(Dir)))
3454 return true;
3455 llvm::sys::path::remove_filename(Dir);
3456 }
3457 return false;
3458}
3459
Mehdi Amini12011172016-10-06 05:11:48 +00003460std::string Driver::GetProgramPath(StringRef Name, const ToolChain &TC) const {
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003461 SmallVector<std::string, 2> TargetSpecificExecutables;
3462 generatePrefixedToolNames(Name, TC, TargetSpecificExecutables);
3463
Chandler Carruth84559242010-03-22 01:52:07 +00003464 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00003465 // attempting to use this prefix when looking for program paths.
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00003466 for (const auto &PrefixDir : PrefixDirs) {
3467 if (llvm::sys::fs::is_directory(PrefixDir)) {
3468 SmallString<128> P(PrefixDir);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003469 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00003470 return P.str();
Simon Atanasyana47ba292012-10-31 14:39:28 +00003471 } else {
Mehdi Amini12011172016-10-06 05:11:48 +00003472 SmallString<128> P((PrefixDir + Name).str());
Rafael Espindola609a6642013-06-24 18:33:43 +00003473 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00003474 return P.str();
Simon Atanasyan86bdab72012-10-31 12:01:53 +00003475 }
Chandler Carruth84559242010-03-22 01:52:07 +00003476 }
3477
Daniel Dunbar68b01a02009-03-18 20:26:19 +00003478 const ToolChain::path_list &List = TC.getProgramPaths();
Saleem Abdulrasool23d99b12014-09-16 03:48:32 +00003479 for (const auto &Path : List) {
3480 SmallString<128> P(Path);
Saleem Abdulrasoolf0ba6ce2014-10-25 23:33:21 +00003481 if (ScanDirForExecutable(P, TargetSpecificExecutables))
Rafael Espindola8be5c052013-06-19 13:24:29 +00003482 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00003483 }
3484
Daniel Dunbar76ce7412009-03-23 16:15:50 +00003485 // If all else failed, search the path.
Michael J. Spencerb011d482014-11-07 21:30:32 +00003486 for (const auto &TargetSpecificExecutable : TargetSpecificExecutables)
3487 if (llvm::ErrorOr<std::string> P =
3488 llvm::sys::findProgramByName(TargetSpecificExecutable))
Michael J. Spencer04162ea2014-11-04 01:30:55 +00003489 return *P;
Daniel Dunbar6f668772009-03-18 21:34:08 +00003490
Daniel Dunbar1ce81532009-09-09 22:33:00 +00003491 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00003492}
3493
Mehdi Amini12011172016-10-06 05:11:48 +00003494std::string Driver::GetTemporaryPath(StringRef Prefix, StringRef Suffix) const {
Rafael Espindola37d229d2013-06-25 04:26:55 +00003495 SmallString<128> Path;
Rafael Espindolac0809172014-06-12 14:02:15 +00003496 std::error_code EC = llvm::sys::fs::createTemporaryFile(Prefix, Suffix, Path);
Rafael Espindola37d229d2013-06-25 04:26:55 +00003497 if (EC) {
3498 Diag(clang::diag::err_unable_to_make_temp) << EC.message();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00003499 return "";
3500 }
3501
Rafael Espindola37d229d2013-06-25 04:26:55 +00003502 return Path.str();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00003503}
3504
Nico Weber2ca4be92016-03-01 23:16:44 +00003505std::string Driver::GetClPchPath(Compilation &C, StringRef BaseName) const {
3506 SmallString<128> Output;
3507 if (Arg *FpArg = C.getArgs().getLastArg(options::OPT__SLASH_Fp)) {
3508 // FIXME: If anybody needs it, implement this obscure rule:
3509 // "If you specify a directory without a file name, the default file name
3510 // is VCx0.pch., where x is the major version of Visual C++ in use."
3511 Output = FpArg->getValue();
3512
3513 // "If you do not specify an extension as part of the path name, an
3514 // extension of .pch is assumed. "
3515 if (!llvm::sys::path::has_extension(Output))
3516 Output += ".pch";
3517 } else {
3518 Output = BaseName;
3519 llvm::sys::path::replace_extension(Output, ".pch");
3520 }
3521 return Output.str();
3522}
3523
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003524const ToolChain &Driver::getToolChain(const ArgList &Args,
Artem Belevich959e0542015-07-10 19:47:55 +00003525 const llvm::Triple &Target) const {
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003526
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00003527 ToolChain *&TC = ToolChains[Target.str()];
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003528 if (!TC) {
3529 switch (Target.getOS()) {
Reid Kleckner330fb172016-05-11 16:19:05 +00003530 case llvm::Triple::Haiku:
3531 TC = new toolchains::Haiku(*this, Target, Args);
3532 break;
Ed Schouten3c3e58c2015-03-26 11:13:44 +00003533 case llvm::Triple::CloudABI:
3534 TC = new toolchains::CloudABI(*this, Target, Args);
3535 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003536 case llvm::Triple::Darwin:
3537 case llvm::Triple::MacOSX:
3538 case llvm::Triple::IOS:
Tim Northover6f3ff222015-10-30 16:30:27 +00003539 case llvm::Triple::TvOS:
3540 case llvm::Triple::WatchOS:
Rafael Espindola14627962013-11-24 23:28:23 +00003541 TC = new toolchains::DarwinClang(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003542 break;
3543 case llvm::Triple::DragonFly:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003544 TC = new toolchains::DragonFly(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003545 break;
3546 case llvm::Triple::OpenBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003547 TC = new toolchains::OpenBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003548 break;
Eli Friedman9fa28852012-08-08 23:57:20 +00003549 case llvm::Triple::Bitrig:
3550 TC = new toolchains::Bitrig(*this, Target, Args);
3551 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003552 case llvm::Triple::NetBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003553 TC = new toolchains::NetBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003554 break;
3555 case llvm::Triple::FreeBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003556 TC = new toolchains::FreeBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003557 break;
3558 case llvm::Triple::Minix:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003559 TC = new toolchains::Minix(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003560 break;
3561 case llvm::Triple::Linux:
Andrey Turetskiy4798eb62016-06-16 10:36:09 +00003562 case llvm::Triple::ELFIAMCU:
Chandler Carruthcf705b22012-01-25 21:03:58 +00003563 if (Target.getArch() == llvm::Triple::hexagon)
Douglas Katzman54366072015-07-27 16:53:08 +00003564 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Vasileios Kalintirisc744e122015-11-12 15:26:54 +00003565 else if ((Target.getVendor() == llvm::Triple::MipsTechnologies) &&
3566 !Target.hasEnvironment())
3567 TC = new toolchains::MipsLLVMToolChain(*this, Target, Args);
Chandler Carruthcf705b22012-01-25 21:03:58 +00003568 else
Rafael Espindola1af7c212012-02-19 01:38:32 +00003569 TC = new toolchains::Linux(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003570 break;
Derek Schuff6ab52fa2015-03-30 20:31:33 +00003571 case llvm::Triple::NaCl:
Douglas Katzman54366072015-07-27 16:53:08 +00003572 TC = new toolchains::NaClToolChain(*this, Target, Args);
Derek Schuff6ab52fa2015-03-30 20:31:33 +00003573 break;
Petr Hosek62e1d232016-10-06 06:08:09 +00003574 case llvm::Triple::Fuchsia:
3575 TC = new toolchains::Fuchsia(*this, Target, Args);
3576 break;
David Chisnallf571cde2012-02-15 13:39:01 +00003577 case llvm::Triple::Solaris:
Rafael Espindola1af7c212012-02-19 01:38:32 +00003578 TC = new toolchains::Solaris(*this, Target, Args);
David Chisnallf571cde2012-02-15 13:39:01 +00003579 break;
Tom Stellard8fa33092015-07-18 01:49:05 +00003580 case llvm::Triple::AMDHSA:
3581 TC = new toolchains::AMDGPUToolChain(*this, Target, Args);
3582 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003583 case llvm::Triple::Win32:
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003584 switch (Target.getEnvironment()) {
3585 default:
3586 if (Target.isOSBinFormatELF())
3587 TC = new toolchains::Generic_ELF(*this, Target, Args);
3588 else if (Target.isOSBinFormatMachO())
3589 TC = new toolchains::MachO(*this, Target, Args);
3590 else
3591 TC = new toolchains::Generic_GCC(*this, Target, Args);
3592 break;
3593 case llvm::Triple::GNU:
Yaron Keren1c0070c2015-07-02 04:45:27 +00003594 TC = new toolchains::MinGW(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003595 break;
Saleem Abdulrasool543a78b2014-10-24 03:13:37 +00003596 case llvm::Triple::Itanium:
3597 TC = new toolchains::CrossWindowsToolChain(*this, Target, Args);
3598 break;
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003599 case llvm::Triple::MSVC:
3600 case llvm::Triple::UnknownEnvironment:
Saleem Abdulrasool819f3912014-10-22 02:37:29 +00003601 TC = new toolchains::MSVCToolChain(*this, Target, Args);
Saleem Abdulrasool377066a2014-03-27 22:50:18 +00003602 break;
3603 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003604 break;
Artem Belevich0ff05cd2015-07-13 23:27:56 +00003605 case llvm::Triple::CUDA:
3606 TC = new toolchains::CudaToolChain(*this, Target, Args);
3607 break;
Filipe Cabecinhasc888e192015-10-14 12:25:43 +00003608 case llvm::Triple::PS4:
3609 TC = new toolchains::PS4CPU(*this, Target, Args);
3610 break;
David L Kreitzerd397ea42016-10-14 20:44:33 +00003611 case llvm::Triple::Contiki:
3612 TC = new toolchains::Contiki(*this, Target, Args);
3613 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003614 default:
Douglas Katzman9f5e70e2015-05-26 18:01:33 +00003615 // Of these targets, Hexagon is the only one that might have
3616 // an OS of Linux, in which case it got handled above already.
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003617 switch (Target.getArch()) {
3618 case llvm::Triple::tce:
Rafael Espindola84b588b2013-03-18 18:10:27 +00003619 TC = new toolchains::TCEToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003620 break;
3621 case llvm::Triple::hexagon:
Douglas Katzman54366072015-07-27 16:53:08 +00003622 TC = new toolchains::HexagonToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003623 break;
Jacques Pienaard964cc22016-03-28 21:02:54 +00003624 case llvm::Triple::lanai:
3625 TC = new toolchains::LanaiToolChain(*this, Target, Args);
3626 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003627 case llvm::Triple::xcore:
Douglas Katzman54366072015-07-27 16:53:08 +00003628 TC = new toolchains::XCoreToolChain(*this, Target, Args);
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003629 break;
Dan Gohmanc2853072015-09-03 22:51:53 +00003630 case llvm::Triple::wasm32:
3631 case llvm::Triple::wasm64:
3632 TC = new toolchains::WebAssembly(*this, Target, Args);
3633 break;
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003634 default:
Douglas Katzmand6e597c2015-09-17 19:56:40 +00003635 if (Target.getVendor() == llvm::Triple::Myriad)
3636 TC = new toolchains::MyriadToolChain(*this, Target, Args);
3637 else if (Target.isOSBinFormatELF())
Douglas Katzman15a63ed2015-08-12 18:36:12 +00003638 TC = new toolchains::Generic_ELF(*this, Target, Args);
3639 else if (Target.isOSBinFormatMachO())
3640 TC = new toolchains::MachO(*this, Target, Args);
3641 else
3642 TC = new toolchains::Generic_GCC(*this, Target, Args);
3643 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00003644 }
3645 }
3646 return *TC;
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00003647}
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00003648
Rafael Espindola2f69d402013-03-18 15:33:26 +00003649bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
Douglas Katzman00249092015-06-12 15:45:21 +00003650 // Say "no" if there is not exactly one input of a type clang understands.
Nico Weber5a459f82016-02-23 19:30:43 +00003651 if (JA.size() != 1 ||
3652 !types::isAcceptedByClang((*JA.input_begin())->getType()))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003653 return false;
3654
Douglas Katzman00249092015-06-12 15:45:21 +00003655 // And say "no" if this is not a kind of action clang understands.
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003656 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
Bob Wilson23a55f12014-12-21 07:00:00 +00003657 !isa<CompileJobAction>(JA) && !isa<BackendJobAction>(JA))
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00003658 return false;
3659
3660 return true;
3661}
3662
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00003663/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
3664/// grouped values as integers. Numbers which are not provided are set to 0.
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003665///
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00003666/// \return True if the entire string was parsed (9.2), or all groups were
3667/// parsed (10.3.5extrastuff).
Mehdi Amini12011172016-10-06 05:11:48 +00003668bool Driver::GetReleaseVersion(StringRef Str, unsigned &Major, unsigned &Minor,
3669 unsigned &Micro, bool &HadExtra) {
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003670 HadExtra = false;
3671
3672 Major = Minor = Micro = 0;
Mehdi Amini12011172016-10-06 05:11:48 +00003673 if (Str.empty())
Bob Wilson433cb312015-04-07 01:03:35 +00003674 return false;
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003675
Mehdi Amini12011172016-10-06 05:11:48 +00003676 if (Str.consumeInteger(10, Major))
3677 return false;
3678 if (Str.empty())
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003679 return true;
Mehdi Amini12011172016-10-06 05:11:48 +00003680 if (Str[0] != '.')
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003681 return false;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00003682
Mehdi Amini12011172016-10-06 05:11:48 +00003683 Str = Str.drop_front(1);
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003684
Mehdi Amini12011172016-10-06 05:11:48 +00003685 if (Str.consumeInteger(10, Minor))
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003686 return false;
Mehdi Amini12011172016-10-06 05:11:48 +00003687 if (Str.empty())
3688 return true;
3689 if (Str[0] != '.')
3690 return false;
3691 Str = Str.drop_front(1);
3692
3693 if (Str.consumeInteger(10, Micro))
3694 return false;
3695 if (!Str.empty())
3696 HadExtra = true;
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00003697 return true;
3698}
Hans Wennborg6ddc6902013-07-27 00:23:45 +00003699
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003700/// Parse digits from a string \p Str and fulfill \p Digits with
3701/// the parsed numbers. This method assumes that the max number of
3702/// digits to look for is equal to Digits.size().
3703///
3704/// \return True if the entire string was parsed and there are
3705/// no extra characters remaining at the end.
Mehdi Amini12011172016-10-06 05:11:48 +00003706bool Driver::GetReleaseVersion(StringRef Str,
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003707 MutableArrayRef<unsigned> Digits) {
Mehdi Amini12011172016-10-06 05:11:48 +00003708 if (Str.empty())
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003709 return false;
3710
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003711 unsigned CurDigit = 0;
3712 while (CurDigit < Digits.size()) {
Mehdi Amini12011172016-10-06 05:11:48 +00003713 unsigned Digit;
3714 if (Str.consumeInteger(10, Digit))
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003715 return false;
Mehdi Amini12011172016-10-06 05:11:48 +00003716 Digits[CurDigit] = Digit;
3717 if (Str.empty())
3718 return true;
3719 if (Str[0] != '.')
3720 return false;
3721 Str = Str.drop_front(1);
Bruno Cardoso Lopes8ed5cac2016-03-31 02:45:46 +00003722 CurDigit++;
3723 }
3724
3725 // More digits than requested, bail out...
3726 return false;
3727}
3728
Hans Wennborg6ddc6902013-07-27 00:23:45 +00003729std::pair<unsigned, unsigned> Driver::getIncludeExcludeOptionFlagMasks() const {
3730 unsigned IncludedFlagsBitmask = 0;
Rafael Espindolacc707bc2013-09-25 15:54:41 +00003731 unsigned ExcludedFlagsBitmask = options::NoDriverOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00003732
3733 if (Mode == CLMode) {
Hans Wennborg19076102013-07-31 20:51:53 +00003734 // Include CL and Core options.
3735 IncludedFlagsBitmask |= options::CLOption;
3736 IncludedFlagsBitmask |= options::CoreOption;
Hans Wennborg6ddc6902013-07-27 00:23:45 +00003737 } else {
3738 ExcludedFlagsBitmask |= options::CLOption;
3739 }
3740
3741 return std::make_pair(IncludedFlagsBitmask, ExcludedFlagsBitmask);
3742}
Benjamin Kramerab88f622014-03-25 18:02:07 +00003743
Douglas Katzmanf08fadf2015-06-04 14:40:44 +00003744bool clang::driver::isOptimizationLevelFast(const ArgList &Args) {
Benjamin Kramerab88f622014-03-25 18:02:07 +00003745 return Args.hasFlag(options::OPT_Ofast, options::OPT_O_Group, false);
3746}