blob: 43b66ba9ee1e59fb5dd4ac3bfd53e9c79d2af314 [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"
Daniel Dunbar1688f1a2009-03-12 07:58:46 +000014#include "clang/Driver/Action.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000015#include "clang/Driver/Compilation.h"
Daniel Dunbarc0b3e952009-03-12 08:55:43 +000016#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000017#include "clang/Driver/Job.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000018#include "clang/Driver/Options.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000019#include "clang/Driver/Tool.h"
20#include "clang/Driver/ToolChain.h"
Chris Lattnerce6c42f2011-03-23 04:04:01 +000021#include "llvm/ADT/ArrayRef.h"
Ted Kremenekbb1110a2010-01-19 01:29:05 +000022#include "llvm/ADT/OwningPtr.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000023#include "llvm/ADT/StringSet.h"
Reid Kleckner898229a2013-06-14 17:17:23 +000024#include "llvm/Option/Arg.h"
25#include "llvm/Option/ArgList.h"
26#include "llvm/Option/OptTable.h"
27#include "llvm/Option/Option.h"
28#include "llvm/Option/OptSpecifier.h"
Eric Christopher2ba5fcb2013-02-05 07:29:57 +000029#include "llvm/Support/Debug.h"
David Blaikie79000202011-09-23 05:57:42 +000030#include "llvm/Support/ErrorHandling.h"
Michael J. Spencerf28df4c2010-12-17 21:22:22 +000031#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000032#include "llvm/Support/Path.h"
Rafael Espindola1600a532013-06-17 17:23:47 +000033#include "llvm/Support/PathV1.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000034#include "llvm/Support/PrettyStackTrace.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000035#include "llvm/Support/Program.h"
Chandler Carruth3a022472012-12-04 09:13:33 +000036#include "llvm/Support/raw_ostream.h"
Dylan Noblesmith4f4e7452012-02-02 00:40:14 +000037#include <map>
Dylan Noblesmith86780e92012-02-01 14:25:28 +000038
Eric Christopherc32fb592013-02-18 04:38:06 +000039// FIXME: It would prevent us from including llvm-config.h
40// if config.h were included before system_error.h.
NAKAMURA Takumieaceff92012-12-05 04:56:27 +000041#include "clang/Config/config.h"
42
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000043using namespace clang::driver;
Chris Lattnerada1c912009-03-26 05:56:24 +000044using namespace clang;
Reid Kleckner898229a2013-06-14 17:17:23 +000045using namespace llvm::opt;
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000046
Chris Lattner0e62c1c2011-07-23 10:55:15 +000047Driver::Driver(StringRef ClangExecutable,
Sebastian Pop9d66d9e2012-01-13 20:36:46 +000048 StringRef DefaultTargetTriple,
Chris Lattner0e62c1c2011-07-23 10:55:15 +000049 StringRef DefaultImageName,
David Blaikie9c902b52011-09-25 23:23:43 +000050 DiagnosticsEngine &Diags)
Nick Lewycky62188bb2011-06-04 05:19:42 +000051 : Opts(createDriverOptTable()), Diags(Diags),
Sebastian Pop980920a2012-04-16 04:16:43 +000052 ClangExecutable(ClangExecutable), SysRoot(DEFAULT_SYSROOT),
53 UseStdLib(true), DefaultTargetTriple(DefaultTargetTriple),
Chad Rosier1b9c5f12012-01-14 00:30:11 +000054 DefaultImageName(DefaultImageName),
Bob Wilson1ec4a5e2012-09-14 03:35:42 +000055 DriverTitle("clang LLVM compiler"),
Daniel Dunbar529c03b2011-04-07 18:01:20 +000056 CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
57 CCLogDiagnosticsFilename(0), CCCIsCXX(false),
Joerg Sonnenberger9c8ad5f2011-03-07 00:09:32 +000058 CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false),
Daniel Dunbar529c03b2011-04-07 18:01:20 +000059 CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
Chad Rosierbe10f982011-08-02 17:58:04 +000060 CCGenDiagnostics(false), CCCGenericGCCName(""), CheckInputsExist(true),
Bob Wilsond0de8ce2012-11-08 01:03:29 +000061 CCCUsePCH(true), SuppressMissingInputWarning(false) {
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +000062
Michael J. Spencere47230f2010-12-18 04:13:32 +000063 Name = llvm::sys::path::stem(ClangExecutable);
64 Dir = llvm::sys::path::parent_path(ClangExecutable);
Bob Wilsona20a1da2013-03-23 05:17:59 +000065
66 // Compute the path to the resource directory.
67 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
68 SmallString<128> P(Dir);
69 if (ClangResourceDir != "")
70 llvm::sys::path::append(P, ClangResourceDir);
71 else
72 llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
73 ResourceDir = P.str();
Daniel Dunbar544ecd12009-03-02 19:59:07 +000074}
75
76Driver::~Driver() {
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000077 delete Opts;
Chandler Carruth2ad5de12012-01-25 11:01:57 +000078
79 for (llvm::StringMap<ToolChain *>::iterator I = ToolChains.begin(),
80 E = ToolChains.end();
81 I != E; ++I)
82 delete I->second;
Daniel Dunbar544ecd12009-03-02 19:59:07 +000083}
84
Chris Lattner54b16772011-07-23 17:14:25 +000085InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +000086 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +000087 unsigned MissingArgIndex, MissingArgCount;
Chris Lattnerce6c42f2011-03-23 04:04:01 +000088 InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +000089 MissingArgIndex, MissingArgCount);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +000090
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +000091 // Check for missing argument error.
92 if (MissingArgCount)
93 Diag(clang::diag::err_drv_missing_argument)
94 << Args->getArgString(MissingArgIndex) << MissingArgCount;
Daniel Dunbar65229332009-03-13 11:38:42 +000095
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +000096 // Check for unsupported options.
97 for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
98 it != ie; ++it) {
99 Arg *A = *it;
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000100 if (A->getOption().hasFlag(options::Unsupported)) {
Daniel Dunbard8500f32009-03-22 23:26:43 +0000101 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
102 continue;
103 }
Chad Rosierce975d92012-02-22 17:55:22 +0000104
105 // Warn about -mcpu= without an argument.
Chad Rosier62135492012-07-09 17:31:28 +0000106 if (A->getOption().matches(options::OPT_mcpu_EQ) &&
Chad Rosierce975d92012-02-22 17:55:22 +0000107 A->containsValue("")) {
Chad Rosier62135492012-07-09 17:31:28 +0000108 Diag(clang::diag::warn_drv_empty_joined_argument) <<
109 A->getAsString(*Args);
Chad Rosierce975d92012-02-22 17:55:22 +0000110 }
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000111 }
112
113 return Args;
114}
115
Chad Rosier7742b5d2011-07-27 23:36:45 +0000116// Determine which compilation mode we are in. We look for options which
117// affect the phase, starting with the earliest phases, and record which
118// option we used to determine the final phase.
119phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
120const {
121 Arg *PhaseArg = 0;
122 phases::ID FinalPhase;
Eric Christopherf901e852011-08-17 22:59:59 +0000123
Chad Rosier7742b5d2011-07-27 23:36:45 +0000124 // -{E,M,MM} only run the preprocessor.
125 if (CCCIsCPP ||
126 (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
127 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) {
128 FinalPhase = phases::Preprocess;
Eric Christopherf901e852011-08-17 22:59:59 +0000129
Chad Rosier7742b5d2011-07-27 23:36:45 +0000130 // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
131 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +0000132 (PhaseArg = DAL.getLastArg(options::OPT_module_file_info)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000133 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
Fariborz Jahanian73223bb2012-04-02 15:59:19 +0000134 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_legacy_objc)) ||
Ted Kremenekf7639e12012-03-06 20:06:33 +0000135 (PhaseArg = DAL.getLastArg(options::OPT__migrate)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000136 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
Chad Rosier1aeb15a2012-03-06 23:14:35 +0000137 options::OPT__analyze_auto)) ||
Chad Rosier7742b5d2011-07-27 23:36:45 +0000138 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) ||
139 (PhaseArg = DAL.getLastArg(options::OPT_S))) {
140 FinalPhase = phases::Compile;
141
142 // -c only runs up to the assembler.
143 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
144 FinalPhase = phases::Assemble;
145
146 // Otherwise do everything.
147 } else
148 FinalPhase = phases::Link;
149
150 if (FinalPhaseArg)
151 *FinalPhaseArg = PhaseArg;
152
153 return FinalPhase;
154}
155
Daniel Dunbar775d4062010-06-11 22:00:26 +0000156DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
157 DerivedArgList *DAL = new DerivedArgList(Args);
158
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000159 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
Daniel Dunbar775d4062010-06-11 22:00:26 +0000160 for (ArgList::const_iterator it = Args.begin(),
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000161 ie = Args.end(); it != ie; ++it) {
162 const Arg *A = *it;
163
164 // Unfortunately, we have to parse some forwarding options (-Xassembler,
165 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
166 // (assembler and preprocessor), or bypass a previous driver ('collect2').
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000167
168 // Rewrite linker options, to replace --no-demangle with a custom internal
169 // option.
170 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
171 A->getOption().matches(options::OPT_Xlinker)) &&
172 A->containsValue("--no-demangle")) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000173 // Add the rewritten no-demangle argument.
174 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
175
176 // Add the remaining values as Xlinker arguments.
177 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Richard Smithbd55daf2012-11-01 04:30:05 +0000178 if (StringRef(A->getValue(i)) != "--no-demangle")
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000179 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
Richard Smithbd55daf2012-11-01 04:30:05 +0000180 A->getValue(i));
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000181
182 continue;
183 }
184
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000185 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
186 // some build systems. We don't try to be complete here because we don't
187 // care to encourage this usage model.
188 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
Richard Smithbd55daf2012-11-01 04:30:05 +0000189 (A->getValue(0) == StringRef("-MD") ||
190 A->getValue(0) == StringRef("-MMD"))) {
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000191 // Rewrite to -MD/-MMD along with -MF.
Richard Smithbd55daf2012-11-01 04:30:05 +0000192 if (A->getValue(0) == StringRef("-MD"))
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000193 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
194 else
195 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
Michael J. Spencer70d85be2012-11-07 23:37:14 +0000196 if (A->getNumValues() == 2)
197 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
198 A->getValue(1));
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000199 continue;
200 }
201
Shantonu Senafeb03b2010-09-17 18:39:08 +0000202 // Rewrite reserved library names.
203 if (A->getOption().matches(options::OPT_l)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000204 StringRef Value = A->getValue();
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000205
Shantonu Senafeb03b2010-09-17 18:39:08 +0000206 // Rewrite unless -nostdlib is present.
207 if (!HasNostdlib && Value == "stdc++") {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000208 DAL->AddFlagArg(A, Opts->getOption(
209 options::OPT_Z_reserved_lib_stdcxx));
210 continue;
211 }
Shantonu Senafeb03b2010-09-17 18:39:08 +0000212
213 // Rewrite unconditionally.
214 if (Value == "cc_kext") {
215 DAL->AddFlagArg(A, Opts->getOption(
216 options::OPT_Z_reserved_lib_cckext));
217 continue;
218 }
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000219 }
220
Daniel Dunbar775d4062010-06-11 22:00:26 +0000221 DAL->append(*it);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000222 }
Daniel Dunbar775d4062010-06-11 22:00:26 +0000223
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000224 // Add a default value of -mlinker-version=, if one was given and the user
225 // didn't specify one.
226#if defined(HOST_LINK_VERSION)
227 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
228 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
229 HOST_LINK_VERSION);
Daniel Dunbarb613ffc2010-08-17 22:32:45 +0000230 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000231 }
232#endif
233
Daniel Dunbar775d4062010-06-11 22:00:26 +0000234 return DAL;
235}
236
Chris Lattner54b16772011-07-23 17:14:25 +0000237Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000238 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
239
Eric Christopherf901e852011-08-17 22:59:59 +0000240 // FIXME: Handle environment options which affect driver behavior, somewhere
Bill Wendlingadbeb9f2012-03-12 21:24:57 +0000241 // (client?). GCC_EXEC_PREFIX, LPATH, CC_PRINT_OPTIONS.
Chad Rosier82301162011-09-14 00:47:55 +0000242
243 if (char *env = ::getenv("COMPILER_PATH")) {
244 StringRef CompilerPath = env;
245 while (!CompilerPath.empty()) {
NAKAMURA Takumiad80c5e2012-12-12 06:22:22 +0000246 std::pair<StringRef, StringRef> Split
247 = CompilerPath.split(llvm::sys::PathSeparator);
Chad Rosier82301162011-09-14 00:47:55 +0000248 PrefixDirs.push_back(Split.first);
249 CompilerPath = Split.second;
250 }
251 }
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000252
253 // FIXME: What are we going to do with -V and -b?
254
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000255 // FIXME: This stuff needs to go into the Compilation, not the driver.
Chad Rosier05e35562013-02-26 22:15:50 +0000256 bool CCCPrintOptions, CCCPrintActions;
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000257
Chris Lattnerce6c42f2011-03-23 04:04:01 +0000258 InputArgList *Args = ParseArgStrings(ArgList.slice(1));
Daniel Dunbaracd69572009-12-04 21:55:23 +0000259
Rafael Espindola59ae7992009-12-07 18:28:29 +0000260 // -no-canonical-prefixes is used very early in main.
261 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
262
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000263 // Ignore -pipe.
264 Args->ClaimAllArgs(options::OPT_pipe);
265
Daniel Dunbaracd69572009-12-04 21:55:23 +0000266 // Extract -ccc args.
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000267 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000268 // FIXME: We need to figure out where this behavior should live. Most of it
269 // should be outside in the client; the parts that aren't should have proper
270 // options, either by introducing new ones or by overloading gcc ones like -V
271 // or -b.
Daniel Dunbaracd69572009-12-04 21:55:23 +0000272 CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
273 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
274 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
Daniel Dunbar1b52d8c2009-12-05 00:13:59 +0000275 CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
Daniel Dunbaracd69572009-12-04 21:55:23 +0000276 CCCEcho = Args->hasArg(options::OPT_ccc_echo);
277 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
Richard Smithbd55daf2012-11-01 04:30:05 +0000278 CCCGenericGCCName = A->getValue();
Daniel Dunbaracd69572009-12-04 21:55:23 +0000279 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
280 options::OPT_ccc_pch_is_pth);
Joerg Sonnenberger17d75512012-02-22 19:15:16 +0000281 // FIXME: DefaultTargetTriple is used by the target-prefixed calls to as/ld
282 // and getToolChain is const.
283 if (const Arg *A = Args->getLastArg(options::OPT_target))
Richard Smithbd55daf2012-11-01 04:30:05 +0000284 DefaultTargetTriple = A->getValue();
Daniel Dunbaracd69572009-12-04 21:55:23 +0000285 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
Richard Smithbd55daf2012-11-01 04:30:05 +0000286 Dir = InstalledDir = A->getValue();
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000287 for (arg_iterator it = Args->filtered_begin(options::OPT_B),
288 ie = Args->filtered_end(); it != ie; ++it) {
289 const Arg *A = *it;
290 A->claim();
Richard Smithbd55daf2012-11-01 04:30:05 +0000291 PrefixDirs.push_back(A->getValue(0));
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000292 }
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +0000293 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
Richard Smithbd55daf2012-11-01 04:30:05 +0000294 SysRoot = A->getValue();
Peter Collingbourne9d9e1fc2013-05-27 21:40:20 +0000295 if (const Arg *A = Args->getLastArg(options::OPT__dyld_prefix_EQ))
296 DyldPrefix = A->getValue();
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +0000297 if (Args->hasArg(options::OPT_nostdlib))
298 UseStdLib = false;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000299
Richard Smithf3e624c2013-03-23 00:30:08 +0000300 if (const Arg *A = Args->getLastArg(options::OPT_resource_dir))
Bob Wilsona20a1da2013-03-23 05:17:59 +0000301 ResourceDir = A->getValue();
Jim Grosbach061dabf2013-03-12 20:17:58 +0000302
Daniel Dunbar775d4062010-06-11 22:00:26 +0000303 // Perform the default argument translations.
304 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
305
Chandler Carruthcb916192012-01-25 08:49:21 +0000306 // Owned by the host.
Chandler Carruth2ad5de12012-01-25 11:01:57 +0000307 const ToolChain &TC = getToolChain(*Args);
Chandler Carruthcb916192012-01-25 08:49:21 +0000308
Daniel Dunbar3ce436d2009-03-16 06:42:30 +0000309 // The compilation takes ownership of Args.
Chandler Carruthcb916192012-01-25 08:49:21 +0000310 Compilation *C = new Compilation(*this, TC, Args, TranslatedArgs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000311
312 // FIXME: This behavior shouldn't be here.
313 if (CCCPrintOptions) {
Daniel Dunbaraf8decb2010-06-11 22:43:38 +0000314 PrintOptions(C->getInputArgs());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000315 return C;
316 }
317
318 if (!HandleImmediateArgs(*C))
319 return C;
320
Chad Rosierecdede82011-08-12 22:08:57 +0000321 // Construct the list of inputs.
322 InputList Inputs;
323 BuildInputs(C->getDefaultToolChain(), C->getArgs(), Inputs);
324
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000325 // Construct the list of abstract actions to perform for this compilation. On
326 // Darwin target OSes this uses the driver-driver and universal actions.
Chandler Carruthcb916192012-01-25 08:49:21 +0000327 if (TC.getTriple().isOSDarwin())
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000328 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
Chad Rosierecdede82011-08-12 22:08:57 +0000329 Inputs, C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000330 else
Chad Rosierecdede82011-08-12 22:08:57 +0000331 BuildActions(C->getDefaultToolChain(), C->getArgs(), Inputs,
332 C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000333
334 if (CCCPrintActions) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000335 PrintActions(*C);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000336 return C;
337 }
338
339 BuildJobs(*C);
Daniel Dunbaradc91e62009-03-15 01:38:15 +0000340
341 return C;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000342}
343
Eric Christopherf901e852011-08-17 22:59:59 +0000344// When clang crashes, produce diagnostic information including the fully
345// preprocessed source file(s). Request that the developer attach the
Chad Rosierbe10f982011-08-02 17:58:04 +0000346// diagnostic information to a bug report.
347void Driver::generateCompilationDiagnostics(Compilation &C,
348 const Command *FailingCommand) {
Chad Rosier877c0a22012-02-22 00:30:39 +0000349 if (C.getArgs().hasArg(options::OPT_fno_crash_diagnostics))
Chad Rosier62135492012-07-09 17:31:28 +0000350 return;
Chad Rosierbee5a1d2012-03-07 00:30:40 +0000351
Chad Rosierdbf46a12013-02-01 18:30:26 +0000352 // Don't try to generate diagnostics for link or dsymutil jobs.
353 if (FailingCommand && (FailingCommand->getCreator().isLinkJob() ||
354 FailingCommand->getCreator().isDsymutilJob()))
Chad Rosier877c0a22012-02-22 00:30:39 +0000355 return;
356
Chad Rosier8179f112012-06-19 17:51:34 +0000357 // Print the version of the compiler.
358 PrintVersion(C, llvm::errs());
359
Chad Rosierbe10f982011-08-02 17:58:04 +0000360 Diag(clang::diag::note_drv_command_failed_diag_msg)
Chad Rosier103e2c92012-06-19 18:39:21 +0000361 << "PLEASE submit a bug report to " BUG_REPORT_URL " and include the "
362 "crash backtrace, preprocessed source, and associated run script.";
Chad Rosierbe10f982011-08-02 17:58:04 +0000363
364 // Suppress driver output and emit preprocessor output to temp file.
365 CCCIsCPP = true;
366 CCGenDiagnostics = true;
David Blaikie5d577a22012-06-29 22:03:56 +0000367 C.getArgs().AddFlagArg(0, Opts->getOption(options::OPT_frewrite_includes));
Chad Rosierbe10f982011-08-02 17:58:04 +0000368
Chad Rosiercdb008d2011-11-02 21:29:05 +0000369 // Save the original job command(s).
370 std::string Cmd;
371 llvm::raw_string_ostream OS(Cmd);
Chad Rosier1c5add62012-05-03 20:17:15 +0000372 if (FailingCommand)
Chad Rosier83f16bf2012-10-31 18:31:33 +0000373 C.PrintDiagnosticJob(OS, *FailingCommand);
Chad Rosier1c5add62012-05-03 20:17:15 +0000374 else
Chad Rosier62135492012-07-09 17:31:28 +0000375 // Crash triggered by FORCE_CLANG_DIAGNOSTICS_CRASH, which doesn't have an
Chad Rosier1c5add62012-05-03 20:17:15 +0000376 // associated FailingCommand, so just pass all jobs.
Chad Rosier83f16bf2012-10-31 18:31:33 +0000377 C.PrintDiagnosticJob(OS, C.getJobs());
Chad Rosiercdb008d2011-11-02 21:29:05 +0000378 OS.flush();
379
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000380 // Keep track of whether we produce any errors while trying to produce
381 // preprocessed sources.
382 DiagnosticErrorTrap Trap(Diags);
383
384 // Suppress tool output.
Chad Rosierbe10f982011-08-02 17:58:04 +0000385 C.initCompilationForDiagnostics();
Chad Rosierecdede82011-08-12 22:08:57 +0000386
387 // Construct the list of inputs.
388 InputList Inputs;
389 BuildInputs(C.getDefaultToolChain(), C.getArgs(), Inputs);
Chad Rosierbe10f982011-08-02 17:58:04 +0000390
Chad Rosier4f81fc22011-08-12 23:30:05 +0000391 for (InputList::iterator it = Inputs.begin(), ie = Inputs.end(); it != ie;) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000392 bool IgnoreInput = false;
393
394 // Ignore input from stdin or any inputs that cannot be preprocessed.
Richard Smithbd55daf2012-11-01 04:30:05 +0000395 if (!strcmp(it->second->getValue(), "-")) {
Chad Rosierd57133d2011-08-18 00:22:25 +0000396 Diag(clang::diag::note_drv_command_failed_diag_msg)
397 << "Error generating preprocessed source(s) - ignoring input from stdin"
398 ".";
399 IgnoreInput = true;
400 } else if (types::getPreprocessedType(it->first) == types::TY_INVALID) {
401 IgnoreInput = true;
402 }
403
404 if (IgnoreInput) {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000405 it = Inputs.erase(it);
406 ie = Inputs.end();
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000407 } else {
Chad Rosier4f81fc22011-08-12 23:30:05 +0000408 ++it;
Chad Rosier6fdf38b2011-08-17 23:08:45 +0000409 }
Chad Rosier4f81fc22011-08-12 23:30:05 +0000410 }
Chad Rosierd57133d2011-08-18 00:22:25 +0000411
Chad Rosierc5103c32013-01-29 23:57:10 +0000412 if (Inputs.empty()) {
413 Diag(clang::diag::note_drv_command_failed_diag_msg)
414 << "Error generating preprocessed source(s) - no preprocessable inputs.";
415 return;
416 }
417
Chad Rosiere75ef402011-09-06 23:52:36 +0000418 // Don't attempt to generate preprocessed files if multiple -arch options are
Chad Rosier636d2832012-02-13 18:16:28 +0000419 // used, unless they're all duplicates.
420 llvm::StringSet<> ArchNames;
Chad Rosiere75ef402011-09-06 23:52:36 +0000421 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
422 it != ie; ++it) {
423 Arg *A = *it;
424 if (A->getOption().matches(options::OPT_arch)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000425 StringRef ArchName = A->getValue();
Chad Rosier636d2832012-02-13 18:16:28 +0000426 ArchNames.insert(ArchName);
Chad Rosiere75ef402011-09-06 23:52:36 +0000427 }
428 }
Chad Rosier636d2832012-02-13 18:16:28 +0000429 if (ArchNames.size() > 1) {
430 Diag(clang::diag::note_drv_command_failed_diag_msg)
431 << "Error generating preprocessed source(s) - cannot generate "
432 "preprocessed source with multiple -arch options.";
433 return;
434 }
Chad Rosiere75ef402011-09-06 23:52:36 +0000435
Chandler Carruth7f1417f2012-01-24 10:43:44 +0000436 // Construct the list of abstract actions to perform for this compilation. On
437 // Darwin OSes this uses the driver-driver and builds universal actions.
Chandler Carruthcb916192012-01-25 08:49:21 +0000438 const ToolChain &TC = C.getDefaultToolChain();
439 if (TC.getTriple().isOSDarwin())
440 BuildUniversalActions(TC, C.getArgs(), Inputs, C.getActions());
Chad Rosierbe10f982011-08-02 17:58:04 +0000441 else
Chandler Carruthcb916192012-01-25 08:49:21 +0000442 BuildActions(TC, C.getArgs(), Inputs, C.getActions());
Chad Rosierbe10f982011-08-02 17:58:04 +0000443
444 BuildJobs(C);
445
446 // If there were errors building the compilation, quit now.
Richard Smith5bb4cdf2012-12-20 02:22:15 +0000447 if (Trap.hasErrorOccurred()) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000448 Diag(clang::diag::note_drv_command_failed_diag_msg)
449 << "Error generating preprocessed source(s).";
450 return;
451 }
452
453 // Generate preprocessed output.
Chad Rosierdd60e092013-01-29 20:15:05 +0000454 SmallVector<std::pair<int, const Command *>, 4> FailingCommands;
455 C.ExecuteJob(C.getJobs(), FailingCommands);
Chad Rosierbe10f982011-08-02 17:58:04 +0000456
457 // If the command succeeded, we are done.
Chad Rosierdd60e092013-01-29 20:15:05 +0000458 if (FailingCommands.empty()) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000459 Diag(clang::diag::note_drv_command_failed_diag_msg)
Chad Rosier103e2c92012-06-19 18:39:21 +0000460 << "\n********************\n\n"
461 "PLEASE ATTACH THE FOLLOWING FILES TO THE BUG REPORT:\n"
462 "Preprocessed source(s) and associated run script(s) are located at:";
Chad Rosierbe10f982011-08-02 17:58:04 +0000463 ArgStringList Files = C.getTempFiles();
Eric Christopherf901e852011-08-17 22:59:59 +0000464 for (ArgStringList::const_iterator it = Files.begin(), ie = Files.end();
Chad Rosiercdb008d2011-11-02 21:29:05 +0000465 it != ie; ++it) {
Chad Rosierbe10f982011-08-02 17:58:04 +0000466 Diag(clang::diag::note_drv_command_failed_diag_msg) << *it;
Chad Rosiercdb008d2011-11-02 21:29:05 +0000467
468 std::string Err;
469 std::string Script = StringRef(*it).rsplit('.').first;
470 Script += ".sh";
471 llvm::raw_fd_ostream ScriptOS(Script.c_str(), Err,
472 llvm::raw_fd_ostream::F_Excl |
473 llvm::raw_fd_ostream::F_Binary);
474 if (!Err.empty()) {
475 Diag(clang::diag::note_drv_command_failed_diag_msg)
476 << "Error generating run script: " + Script + " " + Err;
477 } else {
Chad Rosierdcef5622012-05-03 22:38:00 +0000478 // Append the new filename with correct preprocessed suffix.
479 size_t I, E;
480 I = Cmd.find("-main-file-name ");
481 assert (I != std::string::npos && "Expected to find -main-file-name");
482 I += 16;
483 E = Cmd.find(" ", I);
484 assert (E != std::string::npos && "-main-file-name missing argument?");
Chad Rosieraaec1332012-05-04 15:32:05 +0000485 StringRef OldFilename = StringRef(Cmd).slice(I, E);
486 StringRef NewFilename = llvm::sys::path::filename(*it);
487 I = StringRef(Cmd).rfind(OldFilename);
488 E = I + OldFilename.size();
489 I = Cmd.rfind(" ", I) + 1;
490 Cmd.replace(I, E - I, NewFilename.data(), NewFilename.size());
Chad Rosiercdb008d2011-11-02 21:29:05 +0000491 ScriptOS << Cmd;
492 Diag(clang::diag::note_drv_command_failed_diag_msg) << Script;
493 }
494 }
Chad Rosier103e2c92012-06-19 18:39:21 +0000495 Diag(clang::diag::note_drv_command_failed_diag_msg)
496 << "\n\n********************";
Chad Rosierbe10f982011-08-02 17:58:04 +0000497 } else {
498 // Failure, remove preprocessed files.
Chad Rosier35767232013-04-30 22:01:21 +0000499 if (!C.getArgs().hasArg(options::OPT_save_temps))
Chad Rosierbe10f982011-08-02 17:58:04 +0000500 C.CleanupFileList(C.getTempFiles(), true);
501
502 Diag(clang::diag::note_drv_command_failed_diag_msg)
503 << "Error generating preprocessed source(s).";
504 }
505}
506
507int Driver::ExecuteCompilation(const Compilation &C,
Chad Rosierdd60e092013-01-29 20:15:05 +0000508 SmallVectorImpl< std::pair<int, const Command *> > &FailingCommands) const {
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000509 // Just print if -### was present.
510 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
511 C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
512 return 0;
513 }
514
515 // If there were errors building the compilation, quit now.
Chad Rosierbe10f982011-08-02 17:58:04 +0000516 if (Diags.hasErrorOccurred())
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000517 return 1;
518
Chad Rosierdd60e092013-01-29 20:15:05 +0000519 C.ExecuteJob(C.getJobs(), FailingCommands);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000520
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000521 // Remove temp files.
522 C.CleanupFileList(C.getTempFiles());
523
Daniel Dunbar07494792010-05-22 00:37:20 +0000524 // If the command succeeded, we are done.
Chad Rosierdd60e092013-01-29 20:15:05 +0000525 if (FailingCommands.empty())
526 return 0;
Daniel Dunbar07494792010-05-22 00:37:20 +0000527
Chad Rosierdd60e092013-01-29 20:15:05 +0000528 // Otherwise, remove result files and print extra information about abnormal
529 // failures.
530 for (SmallVectorImpl< std::pair<int, const Command *> >::iterator it =
531 FailingCommands.begin(), ie = FailingCommands.end(); it != ie; ++it) {
532 int Res = it->first;
533 const Command *FailingCommand = it->second;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000534
Chad Rosierdd60e092013-01-29 20:15:05 +0000535 // Remove result files if we're not saving temps.
536 if (!C.getArgs().hasArg(options::OPT_save_temps)) {
537 const JobAction *JA = cast<JobAction>(&FailingCommand->getSource());
538 C.CleanupFileMap(C.getResultFiles(), JA, true);
539
540 // Failure result files are valid unless we crashed.
541 if (Res < 0)
542 C.CleanupFileMap(C.getFailureResultFiles(), JA, true);
543 }
544
545 // Print extra information about abnormal failures, if possible.
546 //
547 // This is ad-hoc, but we don't want to be excessively noisy. If the result
548 // status was 1, assume the command failed normally. In particular, if it
549 // was the compiler then assume it gave a reasonable error code. Failures
550 // in other tools are less common, and they generally have worse
551 // diagnostics, so always print the diagnostic there.
552 const Tool &FailingTool = FailingCommand->getCreator();
553
554 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
555 // FIXME: See FIXME above regarding result code interpretation.
556 if (Res < 0)
557 Diag(clang::diag::err_drv_command_signalled)
558 << FailingTool.getShortName();
559 else
560 Diag(clang::diag::err_drv_command_failed)
561 << FailingTool.getShortName() << Res;
562 }
Peter Collingbourne119cfaa2011-11-21 00:01:05 +0000563 }
Chad Rosierdd60e092013-01-29 20:15:05 +0000564 return 0;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000565}
566
Daniel Dunbar446f6842009-03-12 18:24:49 +0000567void Driver::PrintOptions(const ArgList &Args) const {
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000568 unsigned i = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000569 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000570 it != ie; ++it, ++i) {
571 Arg *A = *it;
572 llvm::errs() << "Option " << i << " - "
Michael J. Spencer929fccd2012-10-22 22:13:48 +0000573 << "Name: \"" << A->getOption().getPrefixedName() << "\", "
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000574 << "Values: {";
575 for (unsigned j = 0; j < A->getNumValues(); ++j) {
576 if (j)
577 llvm::errs() << ", ";
Richard Smithbd55daf2012-11-01 04:30:05 +0000578 llvm::errs() << '"' << A->getValue(j) << '"';
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000579 }
580 llvm::errs() << "}\n";
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000581 }
Daniel Dunbar544ecd12009-03-02 19:59:07 +0000582}
Daniel Dunbar4dff6a42009-03-10 23:41:59 +0000583
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000584void Driver::PrintHelp(bool ShowHidden) const {
Reid Kleckner898229a2013-06-14 17:17:23 +0000585 getOpts().PrintHelp(
586 llvm::outs(), Name.c_str(), DriverTitle.c_str(), /*Include*/ 0,
587 /*Exclude*/ options::NoDriverOption | (ShowHidden ? 0 : HelpHidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +0000588}
589
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000590void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000591 // FIXME: The following handlers should use a callback mechanism, we don't
592 // know what the client would like to do.
Ted Kremenek4c0df3d2010-01-23 02:11:34 +0000593 OS << getClangFullVersion() << '\n';
Daniel Dunbarb10248802009-03-26 16:09:13 +0000594 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000595 OS << "Target: " << TC.getTripleString() << '\n';
Daniel Dunbar10978e42009-06-16 23:32:58 +0000596
597 // Print the threading model.
598 //
599 // FIXME: Implement correctly.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000600 OS << "Thread model: " << "posix" << '\n';
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000601}
602
Chris Lattner86ed5b02010-05-05 05:53:24 +0000603/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
604/// option.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000605static void PrintDiagnosticCategories(raw_ostream &OS) {
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000606 // Skip the empty category.
607 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
608 i != max; ++i)
609 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
Chris Lattner86ed5b02010-05-05 05:53:24 +0000610}
611
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000612bool Driver::HandleImmediateArgs(const Compilation &C) {
Daniel Dunbar18974bd2010-06-11 22:00:19 +0000613 // The order these options are handled in gcc is all over the place, but we
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000614 // don't expect inconsistencies w.r.t. that to matter in practice.
Daniel Dunbar7c925282009-03-31 21:38:17 +0000615
Daniel Dunbar1b09e042010-09-17 02:47:28 +0000616 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
617 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
618 return false;
619 }
620
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000621 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
Daniel Dunbare26e5002011-01-12 00:43:47 +0000622 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
623 // return an answer which matches our definition of __VERSION__.
624 //
625 // If we want to return a more correct answer some day, then we should
626 // introduce a non-pedantically GCC compatible mode to Clang in which we
627 // provide sensible definitions for -dumpversion, __VERSION__, etc.
628 llvm::outs() << "4.2.1\n";
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000629 return false;
630 }
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000631
Chris Lattner86ed5b02010-05-05 05:53:24 +0000632 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
633 PrintDiagnosticCategories(llvm::outs());
634 return false;
635 }
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000636
James Molloya3c85b82012-05-01 14:57:16 +0000637 if (C.getArgs().hasArg(options::OPT_help) ||
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000638 C.getArgs().hasArg(options::OPT__help_hidden)) {
639 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +0000640 return false;
641 }
642
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000643 if (C.getArgs().hasArg(options::OPT__version)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000644 // Follow gcc behavior and use stdout for --version and stderr for -v.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000645 PrintVersion(C, llvm::outs());
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000646 return false;
647 }
648
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000649 if (C.getArgs().hasArg(options::OPT_v) ||
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000650 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000651 PrintVersion(C, llvm::errs());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000652 SuppressMissingInputWarning = true;
653 }
654
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000655 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbard972e222009-03-20 04:37:21 +0000656 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
657 llvm::outs() << "programs: =";
658 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
659 ie = TC.getProgramPaths().end(); it != ie; ++it) {
660 if (it != TC.getProgramPaths().begin())
661 llvm::outs() << ':';
662 llvm::outs() << *it;
663 }
664 llvm::outs() << "\n";
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000665 llvm::outs() << "libraries: =" << ResourceDir;
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000666
Sebastian Pop980920a2012-04-16 04:16:43 +0000667 StringRef sysroot = C.getSysRoot();
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000668
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000669 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
Daniel Dunbard972e222009-03-20 04:37:21 +0000670 ie = TC.getFilePaths().end(); it != ie; ++it) {
Peter Collingbournefa9771f2011-09-06 02:08:31 +0000671 llvm::outs() << ':';
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000672 const char *path = it->c_str();
673 if (path[0] == '=')
674 llvm::outs() << sysroot << path + 1;
675 else
676 llvm::outs() << path;
Daniel Dunbard972e222009-03-20 04:37:21 +0000677 }
678 llvm::outs() << "\n";
Daniel Dunbar7c925282009-03-31 21:38:17 +0000679 return false;
Daniel Dunbard972e222009-03-20 04:37:21 +0000680 }
681
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000682 // FIXME: The following handlers should use a callback mechanism, we don't
683 // know what the client would like to do.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000684 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000685 llvm::outs() << GetFilePath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000686 return false;
687 }
688
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000689 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000690 llvm::outs() << GetProgramPath(A->getValue(), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000691 return false;
692 }
693
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000694 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000695 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000696 return false;
697 }
698
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000699 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
700 // FIXME: We need tool chain support for this.
701 llvm::outs() << ".;\n";
702
703 switch (C.getDefaultToolChain().getTriple().getArch()) {
704 default:
705 break;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000706
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000707 case llvm::Triple::x86_64:
708 llvm::outs() << "x86_64;@m64" << "\n";
709 break;
710
711 case llvm::Triple::ppc64:
712 llvm::outs() << "ppc64;@m64" << "\n";
713 break;
714 }
715 return false;
716 }
717
718 // FIXME: What is the difference between print-multi-directory and
719 // print-multi-os-directory?
720 if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
721 C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
722 switch (C.getDefaultToolChain().getTriple().getArch()) {
723 default:
724 case llvm::Triple::x86:
725 case llvm::Triple::ppc:
726 llvm::outs() << "." << "\n";
727 break;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000728
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000729 case llvm::Triple::x86_64:
730 llvm::outs() << "x86_64" << "\n";
731 break;
732
733 case llvm::Triple::ppc64:
734 llvm::outs() << "ppc64" << "\n";
735 break;
736 }
737 return false;
738 }
739
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000740 return true;
741}
742
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000743static unsigned PrintActions1(const Compilation &C, Action *A,
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000744 std::map<Action*, unsigned> &Ids) {
745 if (Ids.count(A))
746 return Ids[A];
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000747
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000748 std::string str;
749 llvm::raw_string_ostream os(str);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000750
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000751 os << Action::getClassName(A->getKind()) << ", ";
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000752 if (InputAction *IA = dyn_cast<InputAction>(A)) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000753 os << "\"" << IA->getInputArg().getValue() << "\"";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000754 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
Chad Rosier98ab91c2012-04-27 19:51:11 +0000755 os << '"' << BIA->getArchName() << '"'
Daniel Dunbareb843be2009-03-18 03:13:20 +0000756 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000757 } else {
758 os << "{";
759 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000760 os << PrintActions1(C, *it, Ids);
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000761 ++it;
762 if (it != ie)
763 os << ", ";
764 }
765 os << "}";
766 }
767
768 unsigned Id = Ids.size();
769 Ids[A] = Id;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000770 llvm::errs() << Id << ": " << os.str() << ", "
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000771 << types::getTypeName(A->getType()) << "\n";
772
773 return Id;
774}
775
Daniel Dunbareb843be2009-03-18 03:13:20 +0000776void Driver::PrintActions(const Compilation &C) const {
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000777 std::map<Action*, unsigned> Ids;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000778 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbareb843be2009-03-18 03:13:20 +0000779 ie = C.getActions().end(); it != ie; ++it)
780 PrintActions1(C, *it, Ids);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000781}
782
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +0000783/// \brief Check whether the given input tree contains any compilation or
784/// assembly actions.
785static bool ContainsCompileOrAssembleAction(const Action *A) {
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000786 if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
787 return true;
788
789 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +0000790 if (ContainsCompileOrAssembleAction(*it))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000791 return true;
792
793 return false;
794}
795
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000796void Driver::BuildUniversalActions(const ToolChain &TC,
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000797 const DerivedArgList &Args,
Chad Rosierecdede82011-08-12 22:08:57 +0000798 const InputList &BAInputs,
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000799 ActionList &Actions) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000800 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
801 // Collect the list of architectures. Duplicates are allowed, but should only
802 // be handled once (in the order seen).
Daniel Dunbare5dc4822009-03-13 20:33:35 +0000803 llvm::StringSet<> ArchNames;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000804 SmallVector<const char *, 4> Archs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000805 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbarf479c122009-03-12 18:40:18 +0000806 it != ie; ++it) {
807 Arg *A = *it;
808
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000809 if (A->getOption().matches(options::OPT_arch)) {
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +0000810 // Validate the option here; we don't save the type here because its
811 // particular spelling may participate in other driver choices.
812 llvm::Triple::ArchType Arch =
Richard Smithbd55daf2012-11-01 04:30:05 +0000813 tools::darwin::getArchTypeForDarwinArchName(A->getValue());
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +0000814 if (Arch == llvm::Triple::UnknownArch) {
815 Diag(clang::diag::err_drv_invalid_arch_name)
816 << A->getAsString(Args);
817 continue;
818 }
819
Daniel Dunbar2da02722009-03-19 07:55:12 +0000820 A->claim();
Richard Smithbd55daf2012-11-01 04:30:05 +0000821 if (ArchNames.insert(A->getValue()))
822 Archs.push_back(A->getValue());
Daniel Dunbarf479c122009-03-12 18:40:18 +0000823 }
824 }
825
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000826 // When there is no explicit arch for this platform, make sure we still bind
827 // the architecture (to the default) so that -Xarch_ is handled correctly.
Daniel Dunbareb843be2009-03-18 03:13:20 +0000828 if (!Archs.size())
Daniel Dunbarc3bd9f52012-11-08 03:38:26 +0000829 Archs.push_back(Args.MakeArgString(TC.getDefaultUniversalArchName()));
Daniel Dunbarf479c122009-03-12 18:40:18 +0000830
Daniel Dunbarf479c122009-03-12 18:40:18 +0000831 ActionList SingleActions;
Chad Rosierecdede82011-08-12 22:08:57 +0000832 BuildActions(TC, Args, BAInputs, SingleActions);
Daniel Dunbarf479c122009-03-12 18:40:18 +0000833
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000834 // Add in arch bindings for every top level action, as well as lipo and
835 // dsymutil steps if needed.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000836 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
837 Action *Act = SingleActions[i];
838
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000839 // Make sure we can lipo this kind of output. If not (and it is an actual
840 // output) then we disallow, since we can't create an output file with the
841 // right name without overwriting it. We could remove this oddity by just
842 // changing the output names to include the arch, which would also fix
Daniel Dunbarf479c122009-03-12 18:40:18 +0000843 // -save-temps. Compatibility wins for now.
844
Daniel Dunbare2ca3bd2009-03-13 17:46:02 +0000845 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
Daniel Dunbarf479c122009-03-12 18:40:18 +0000846 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
847 << types::getTypeName(Act->getType());
848
849 ActionList Inputs;
Daniel Dunbar66187b32010-03-11 18:04:58 +0000850 for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
Daniel Dunbare5dc4822009-03-13 20:33:35 +0000851 Inputs.push_back(new BindArchAction(Act, Archs[i]));
Daniel Dunbar66187b32010-03-11 18:04:58 +0000852 if (i != 0)
853 Inputs.back()->setOwnsInputs(false);
854 }
Daniel Dunbarf479c122009-03-12 18:40:18 +0000855
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000856 // Lipo if necessary, we do it this way because we need to set the arch flag
857 // so that -Xarch_ gets overwritten.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000858 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
859 Actions.append(Inputs.begin(), Inputs.end());
860 else
861 Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000862
Eric Christopher65c05fa2012-02-06 19:43:51 +0000863 // Handle debug info queries.
864 Arg *A = Args.getLastArg(options::OPT_g_Group);
David Blaikie6f9f4eb2012-04-15 21:22:10 +0000865 if (A && !A->getOption().matches(options::OPT_g0) &&
866 !A->getOption().matches(options::OPT_gstabs) &&
867 ContainsCompileOrAssembleAction(Actions.back())) {
Chad Rosier62135492012-07-09 17:31:28 +0000868
David Blaikie6f9f4eb2012-04-15 21:22:10 +0000869 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
870 // have a compile input. We need to run 'dsymutil' ourselves in such cases
Eric Christopher776c26f2013-01-28 17:39:03 +0000871 // because the debug info will refer to a temporary object file which
David Blaikie6f9f4eb2012-04-15 21:22:10 +0000872 // will be removed at the end of the compilation process.
873 if (Act->getType() == types::TY_Image) {
874 ActionList Inputs;
875 Inputs.push_back(Actions.back());
876 Actions.pop_back();
877 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000878 }
David Blaikie6f9f4eb2012-04-15 21:22:10 +0000879
880 // Verify the output (debug information only) if we passed '-verify'.
881 if (Args.hasArg(options::OPT_verify)) {
882 ActionList VerifyInputs;
883 VerifyInputs.push_back(Actions.back());
884 Actions.pop_back();
885 Actions.push_back(new VerifyJobAction(VerifyInputs,
886 types::TY_Nothing));
887 }
888 }
Daniel Dunbarf479c122009-03-12 18:40:18 +0000889 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000890}
891
Chad Rosierecdede82011-08-12 22:08:57 +0000892// Construct a the list of inputs and their types.
893void Driver::BuildInputs(const ToolChain &TC, const DerivedArgList &Args,
894 InputList &Inputs) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000895 // Track the current user specified (-x) input. We also explicitly track the
896 // argument used to set the type; we only want to claim the type when we
897 // actually use it, so we warn about unused -x arguments.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +0000898 types::ID InputType = types::TY_Nothing;
899 Arg *InputTypeArg = 0;
900
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000901 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000902 it != ie; ++it) {
903 Arg *A = *it;
904
Michael J. Spencerad3ccc32012-08-20 21:41:17 +0000905 if (A->getOption().getKind() == Option::InputClass) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000906 const char *Value = A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000907 types::ID Ty = types::TY_INVALID;
908
909 // Infer the input type if necessary.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +0000910 if (InputType == types::TY_Nothing) {
911 // If there was an explicit arg for this, claim it.
912 if (InputTypeArg)
913 InputTypeArg->claim();
914
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000915 // stdin must be handled specially.
916 if (memcmp(Value, "-", 2) == 0) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000917 // If running with -E, treat as a C input (this changes the builtin
918 // macros, for example). This may be overridden by -ObjC below.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000919 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000920 // Otherwise emit an error but still use a valid type to avoid
921 // spurious errors (e.g., no inputs).
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +0000922 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP)
Daniel Dunbar5cd1e412009-03-12 09:13:48 +0000923 Diag(clang::diag::err_drv_unknown_stdin_type);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000924 Ty = types::TY_C;
925 } else {
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +0000926 // Otherwise lookup by extension.
927 // Fallback is C if invoked as C preprocessor or Object otherwise.
928 // We use a host hook here because Darwin at least has its own
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000929 // idea of what .s is.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000930 if (const char *Ext = strrchr(Value, '.'))
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +0000931 Ty = TC.LookupTypeForExtension(Ext + 1);
Daniel Dunbarea9f0322009-03-20 23:39:23 +0000932
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +0000933 if (Ty == types::TY_INVALID) {
934 if (CCCIsCPP)
935 Ty = types::TY_C;
936 else
937 Ty = types::TY_Object;
938 }
Daniel Dunbar0ac94452010-02-17 20:32:58 +0000939
940 // If the driver is invoked as C++ compiler (like clang++ or c++) it
941 // should autodetect some input files as C++ for g++ compatibility.
942 if (CCCIsCXX) {
943 types::ID OldTy = Ty;
944 Ty = types::lookupCXXTypeForCType(Ty);
945
946 if (Ty != OldTy)
947 Diag(clang::diag::warn_drv_treating_input_as_cxx)
948 << getTypeName(OldTy) << getTypeName(Ty);
949 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000950 }
951
Daniel Dunbar82b22102009-05-18 21:47:54 +0000952 // -ObjC and -ObjC++ override the default language, but only for "source
953 // files". We just treat everything that isn't a linker input as a
954 // source file.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000955 //
Daniel Dunbar82b22102009-05-18 21:47:54 +0000956 // FIXME: Clean this up if we move the phase sequence into the type.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000957 if (Ty != types::TY_Object) {
958 if (Args.hasArg(options::OPT_ObjC))
959 Ty = types::TY_ObjC;
960 else if (Args.hasArg(options::OPT_ObjCXX))
961 Ty = types::TY_ObjCXX;
962 }
963 } else {
964 assert(InputTypeArg && "InputType set w/o InputTypeArg");
965 InputTypeArg->claim();
966 Ty = InputType;
967 }
968
Daniel Dunbarfcf2d422010-01-25 00:44:02 +0000969 // Check that the file exists, if enabled.
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000970 if (CheckInputsExist && memcmp(Value, "-", 2) != 0) {
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +0000971 SmallString<64> Path(Value);
Aaron Ballman232c4f52012-02-20 14:13:25 +0000972 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory)) {
Argyrios Kyrtzidisc2c77c42012-10-26 20:09:24 +0000973 if (!llvm::sys::path::is_absolute(Path.str())) {
Richard Smithbd55daf2012-11-01 04:30:05 +0000974 SmallString<64> Directory(WorkDir->getValue());
Aaron Ballman232c4f52012-02-20 14:13:25 +0000975 llvm::sys::path::append(Directory, Value);
976 Path.assign(Directory);
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000977 }
Aaron Ballman232c4f52012-02-20 14:13:25 +0000978 }
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000979
Rafael Espindola02940752013-06-24 18:19:15 +0000980 if (!llvm::sys::fs::exists(Twine(Path)))
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000981 Diag(clang::diag::err_drv_no_such_file) << Path.str();
982 else
983 Inputs.push_back(std::make_pair(Ty, A));
984 } else
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000985 Inputs.push_back(std::make_pair(Ty, A));
986
Michael J. Spencer66e2b202012-10-19 22:37:06 +0000987 } else if (A->getOption().hasFlag(options::LinkerInput)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000988 // Just treat as object type, we could make a special type for this if
989 // necessary.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000990 Inputs.push_back(std::make_pair(types::TY_Object, A));
991
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000992 } else if (A->getOption().matches(options::OPT_x)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000993 InputTypeArg = A;
Richard Smithbd55daf2012-11-01 04:30:05 +0000994 InputType = types::lookupTypeForTypeSpecifier(A->getValue());
Chad Rosier706c2352012-04-07 00:01:31 +0000995 A->claim();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000996
997 // Follow gcc behavior and treat as linker input for invalid -x
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000998 // options. Its not clear why we shouldn't just revert to unknown; but
Michael J. Spencer1a4fe8c2010-12-17 21:22:33 +0000999 // this isn't very important, we might as well be bug compatible.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001000 if (!InputType) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001001 Diag(clang::diag::err_drv_unknown_language) << A->getValue();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001002 InputType = types::TY_Object;
1003 }
1004 }
1005 }
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001006 if (CCCIsCPP && Inputs.empty()) {
1007 // If called as standalone preprocessor, stdin is processed
1008 // if no other input is present.
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +00001009 unsigned Index = Args.getBaseArgs().MakeIndex("-");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001010 Arg *A = Opts->ParseOneArg(Args, Index);
1011 A->claim();
1012 Inputs.push_back(std::make_pair(types::TY_C, A));
1013 }
Chad Rosierecdede82011-08-12 22:08:57 +00001014}
1015
1016void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args,
1017 const InputList &Inputs, ActionList &Actions) const {
1018 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +00001019
Daniel Dunbar34c41872009-03-13 00:17:48 +00001020 if (!SuppressMissingInputWarning && Inputs.empty()) {
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001021 Diag(clang::diag::err_drv_no_input_files);
1022 return;
1023 }
1024
Chad Rosier7742b5d2011-07-27 23:36:45 +00001025 Arg *FinalPhaseArg;
1026 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001027
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001028 // Reject -Z* at the top level, these options should never have been exposed
1029 // by gcc.
Daniel Dunbardd765242009-03-26 16:12:09 +00001030 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Daniel Dunbar0e759942009-03-20 06:14:23 +00001031 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
Daniel Dunbarbfeec742009-03-12 23:55:14 +00001032
Daniel Dunbar65229332009-03-13 11:38:42 +00001033 // Construct the actions to perform.
1034 ActionList LinkerInputs;
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00001035 ActionList SplitInputs;
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001036 llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases> PL;
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001037 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
Daniel Dunbar65229332009-03-13 11:38:42 +00001038 types::ID InputType = Inputs[i].first;
1039 const Arg *InputArg = Inputs[i].second;
1040
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001041 PL.clear();
1042 types::getCompilationPhases(InputType, PL);
Daniel Dunbar65229332009-03-13 11:38:42 +00001043
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001044 // If the first step comes after the final phase we are doing as part of
1045 // this compilation, warn the user about it.
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001046 phases::ID InitialPhase = PL[0];
Daniel Dunbar65229332009-03-13 11:38:42 +00001047 if (InitialPhase > FinalPhase) {
Daniel Dunbaradc5c7c2009-03-19 07:57:08 +00001048 // Claim here to avoid the more general unused warning.
1049 InputArg->claim();
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001050
Daniel Dunbar2db3e732011-04-20 15:44:48 +00001051 // Suppress all unused style warnings with -Qunused-arguments
1052 if (Args.hasArg(options::OPT_Qunused_arguments))
1053 continue;
1054
Richard Smith403f76e2012-08-06 04:09:06 +00001055 // Special case when final phase determined by binary name, rather than
1056 // by a command-line argument with a corresponding Arg.
1057 if (CCCIsCPP)
1058 Diag(clang::diag::warn_drv_input_file_unused_by_cpp)
1059 << InputArg->getAsString(Args)
1060 << getPhaseName(InitialPhase);
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001061 // Special case '-E' warning on a previously preprocessed file to make
1062 // more sense.
Richard Smith403f76e2012-08-06 04:09:06 +00001063 else if (InitialPhase == phases::Compile &&
1064 FinalPhase == phases::Preprocess &&
1065 getPreprocessedType(InputType) == types::TY_INVALID)
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001066 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
1067 << InputArg->getAsString(Args)
Richard Smith403f76e2012-08-06 04:09:06 +00001068 << !!FinalPhaseArg
1069 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
Daniel Dunbar07806ca2009-09-17 04:13:26 +00001070 else
1071 Diag(clang::diag::warn_drv_input_file_unused)
1072 << InputArg->getAsString(Args)
1073 << getPhaseName(InitialPhase)
Richard Smith403f76e2012-08-06 04:09:06 +00001074 << !!FinalPhaseArg
1075 << FinalPhaseArg ? FinalPhaseArg->getOption().getName() : "";
Daniel Dunbar65229332009-03-13 11:38:42 +00001076 continue;
1077 }
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001078
Daniel Dunbar65229332009-03-13 11:38:42 +00001079 // Build the pipeline for this file.
Dylan Noblesmithe2778992012-02-05 02:12:40 +00001080 OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001081 for (llvm::SmallVector<phases::ID, phases::MaxNumberOfPhases>::iterator
1082 i = PL.begin(), e = PL.end(); i != e; ++i) {
1083 phases::ID Phase = *i;
Daniel Dunbar65229332009-03-13 11:38:42 +00001084
1085 // We are done if this step is past what the user requested.
1086 if (Phase > FinalPhase)
1087 break;
1088
1089 // Queue linker inputs.
1090 if (Phase == phases::Link) {
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001091 assert((i + 1) == e && "linking must be final compilation step.");
Ted Kremenekbb1110a2010-01-19 01:29:05 +00001092 LinkerInputs.push_back(Current.take());
Daniel Dunbar65229332009-03-13 11:38:42 +00001093 break;
1094 }
1095
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001096 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
1097 // encode this in the steps because the intermediate type depends on
1098 // arguments. Just special case here.
Daniel Dunbar13864952009-03-24 20:17:30 +00001099 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
1100 continue;
1101
Daniel Dunbar65229332009-03-13 11:38:42 +00001102 // Otherwise construct the appropriate action.
Ted Kremenekbb1110a2010-01-19 01:29:05 +00001103 Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
Daniel Dunbar65229332009-03-13 11:38:42 +00001104 if (Current->getType() == types::TY_Nothing)
1105 break;
1106 }
1107
1108 // If we ended with something, add to the output list.
1109 if (Current)
Ted Kremenekbb1110a2010-01-19 01:29:05 +00001110 Actions.push_back(Current.take());
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001111 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001112
1113 // Add a link action if necessary.
1114 if (!LinkerInputs.empty())
1115 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001116
1117 // If we are linking, claim any options which are obviously only used for
1118 // compilation.
Matthew Curtis7ab8b2b2013-03-07 12:32:26 +00001119 if (FinalPhase == phases::Link && PL.size() == 1)
Daniel Dunbarc7a67b72009-12-22 23:19:32 +00001120 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
Daniel Dunbar65229332009-03-13 11:38:42 +00001121}
1122
1123Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
1124 Action *Input) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001125 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
Daniel Dunbar65229332009-03-13 11:38:42 +00001126 // Build the appropriate action.
1127 switch (Phase) {
David Blaikie83d382b2011-09-23 05:06:16 +00001128 case phases::Link: llvm_unreachable("link action invalid here.");
Daniel Dunbar65229332009-03-13 11:38:42 +00001129 case phases::Preprocess: {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001130 types::ID OutputTy;
1131 // -{M, MM} alter the output type.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +00001132 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001133 OutputTy = types::TY_Dependencies;
1134 } else {
David Blaikie5d577a22012-06-29 22:03:56 +00001135 OutputTy = Input->getType();
1136 if (!Args.hasFlag(options::OPT_frewrite_includes,
1137 options::OPT_fno_rewrite_includes, false))
1138 OutputTy = types::getPreprocessedType(OutputTy);
Daniel Dunbard67a3222009-03-30 06:36:42 +00001139 assert(OutputTy != types::TY_INVALID &&
1140 "Cannot preprocess this input type!");
1141 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001142 return new PreprocessJobAction(Input, OutputTy);
1143 }
Aaron Ballman1f10cc52012-07-31 01:21:00 +00001144 case phases::Precompile: {
1145 types::ID OutputTy = types::TY_PCH;
1146 if (Args.hasArg(options::OPT_fsyntax_only)) {
1147 // Syntax checks should not emit a PCH file
1148 OutputTy = types::TY_Nothing;
1149 }
1150 return new PrecompileJobAction(Input, OutputTy);
1151 }
Daniel Dunbar65229332009-03-13 11:38:42 +00001152 case phases::Compile: {
1153 if (Args.hasArg(options::OPT_fsyntax_only)) {
1154 return new CompileJobAction(Input, types::TY_Nothing);
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001155 } else if (Args.hasArg(options::OPT_rewrite_objc)) {
1156 return new CompileJobAction(Input, types::TY_RewrittenObjC);
Fariborz Jahanian73223bb2012-04-02 15:59:19 +00001157 } else if (Args.hasArg(options::OPT_rewrite_legacy_objc)) {
1158 return new CompileJobAction(Input, types::TY_RewrittenLegacyObjC);
Daniel Dunbar5e051f92009-05-06 02:12:32 +00001159 } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
Daniel Dunbar65229332009-03-13 11:38:42 +00001160 return new AnalyzeJobAction(Input, types::TY_Plist);
Ted Kremenekf7639e12012-03-06 20:06:33 +00001161 } else if (Args.hasArg(options::OPT__migrate)) {
1162 return new MigrateJobAction(Input, types::TY_Remap);
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001163 } else if (Args.hasArg(options::OPT_emit_ast)) {
1164 return new CompileJobAction(Input, types::TY_AST);
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00001165 } else if (Args.hasArg(options::OPT_module_file_info)) {
1166 return new CompileJobAction(Input, types::TY_ModuleFile);
Daniel Dunbar8f1fe5b2011-06-21 20:55:08 +00001167 } else if (IsUsingLTO(Args)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001168 types::ID Output =
Daniel Dunbar24e52992010-06-07 23:28:45 +00001169 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
Daniel Dunbar65229332009-03-13 11:38:42 +00001170 return new CompileJobAction(Input, Output);
1171 } else {
1172 return new CompileJobAction(Input, types::TY_PP_Asm);
1173 }
1174 }
1175 case phases::Assemble:
1176 return new AssembleJobAction(Input, types::TY_Object);
1177 }
1178
David Blaikie83d382b2011-09-23 05:06:16 +00001179 llvm_unreachable("invalid phase in ConstructPhaseAction");
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001180}
1181
Daniel Dunbar8f1fe5b2011-06-21 20:55:08 +00001182bool Driver::IsUsingLTO(const ArgList &Args) const {
1183 // Check for -emit-llvm or -flto.
1184 if (Args.hasArg(options::OPT_emit_llvm) ||
1185 Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1186 return true;
1187
1188 // Check for -O4.
1189 if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
1190 return A->getOption().matches(options::OPT_O4);
1191
1192 return false;
1193}
1194
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001195void Driver::BuildJobs(Compilation &C) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001196 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001197
1198 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1199
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001200 // It is an error to provide a -o option if we are making multiple output
1201 // files.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001202 if (FinalOutput) {
1203 unsigned NumOutputs = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001204 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001205 ie = C.getActions().end(); it != ie; ++it)
Daniel Dunbare75d8342009-03-16 06:56:51 +00001206 if ((*it)->getType() != types::TY_Nothing)
1207 ++NumOutputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001208
Daniel Dunbare75d8342009-03-16 06:56:51 +00001209 if (NumOutputs > 1) {
1210 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1211 FinalOutput = 0;
1212 }
1213 }
1214
Chad Rosier35767232013-04-30 22:01:21 +00001215 // Collect the list of architectures.
1216 llvm::StringSet<> ArchNames;
1217 if (C.getDefaultToolChain().getTriple().isOSDarwin()) {
1218 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1219 it != ie; ++it) {
1220 Arg *A = *it;
1221 if (A->getOption().matches(options::OPT_arch))
1222 ArchNames.insert(A->getValue());
1223 }
1224 }
1225
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001226 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001227 ie = C.getActions().end(); it != ie; ++it) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001228 Action *A = *it;
1229
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001230 // If we are linking an image for multiple archs then the linker wants
1231 // -arch_multiple and -final_output <final image name>. Unfortunately, this
1232 // doesn't fit in cleanly because we have to pass this information down.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001233 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001234 // FIXME: This is a hack; find a cleaner way to integrate this into the
1235 // process.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001236 const char *LinkingOutput = 0;
Daniel Dunbardd765242009-03-26 16:12:09 +00001237 if (isa<LipoJobAction>(A)) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001238 if (FinalOutput)
Richard Smithbd55daf2012-11-01 04:30:05 +00001239 LinkingOutput = FinalOutput->getValue();
Daniel Dunbare75d8342009-03-16 06:56:51 +00001240 else
1241 LinkingOutput = DefaultImageName.c_str();
1242 }
1243
1244 InputInfo II;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001245 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001246 /*BoundArch*/0,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001247 /*AtTopLevel*/ true,
Chad Rosier35767232013-04-30 22:01:21 +00001248 /*MultipleArchs*/ ArchNames.size() > 1,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001249 /*LinkingOutput*/ LinkingOutput,
1250 II);
1251 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001252
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001253 // If the user passed -Qunused-arguments or there were errors, don't warn
1254 // about any unused arguments.
Argyrios Kyrtzidis31448a42010-11-18 21:47:07 +00001255 if (Diags.hasErrorOccurred() ||
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001256 C.getArgs().hasArg(options::OPT_Qunused_arguments))
Daniel Dunbard175d972009-03-18 18:03:46 +00001257 return;
1258
Daniel Dunbar58399ae2009-03-29 22:24:54 +00001259 // Claim -### here.
1260 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001261
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001262 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1263 it != ie; ++it) {
1264 Arg *A = *it;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001265
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001266 // FIXME: It would be nice to be able to send the argument to the
David Blaikie9c902b52011-09-25 23:23:43 +00001267 // DiagnosticsEngine, so that extra values, position, and so on could be
1268 // printed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001269 if (!A->isClaimed()) {
Michael J. Spencer66e2b202012-10-19 22:37:06 +00001270 if (A->getOption().hasFlag(options::NoArgumentUnused))
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001271 continue;
1272
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001273 // Suppress the warning automatically if this is just a flag, and it is an
1274 // instance of an argument we already claimed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001275 const Option &Opt = A->getOption();
Michael J. Spencerad3ccc32012-08-20 21:41:17 +00001276 if (Opt.getKind() == Option::FlagClass) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001277 bool DuplicateClaimed = false;
1278
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001279 for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1280 ie = C.getArgs().filtered_end(); it != ie; ++it) {
1281 if ((*it)->isClaimed()) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001282 DuplicateClaimed = true;
1283 break;
1284 }
1285 }
1286
1287 if (DuplicateClaimed)
1288 continue;
1289 }
1290
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001291 Diag(clang::diag::warn_drv_unused_argument)
Daniel Dunbar0e759942009-03-20 06:14:23 +00001292 << A->getAsString(C.getArgs());
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001293 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001294 }
Daniel Dunbar95e6b192009-03-13 22:12:33 +00001295}
1296
Rafael Espindola79764462013-03-24 15:06:53 +00001297static const Tool *SelectToolForJob(Compilation &C, const ToolChain *TC,
Daniel Dunbarc4343942010-02-03 03:07:56 +00001298 const JobAction *JA,
1299 const ActionList *&Inputs) {
1300 const Tool *ToolForJob = 0;
1301
1302 // See if we should look for a compiler with an integrated assembler. We match
1303 // bottom up, so what we are actually looking for is an assembler job with a
1304 // compiler input.
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00001305
Rafael Espindola84b588b2013-03-18 18:10:27 +00001306 if (TC->useIntegratedAs() &&
Daniel Dunbarc4343942010-02-03 03:07:56 +00001307 !C.getArgs().hasArg(options::OPT_save_temps) &&
1308 isa<AssembleJobAction>(JA) &&
1309 Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
Rafael Espindola79764462013-03-24 15:06:53 +00001310 const Tool *Compiler =
Rafael Espindola30212ab2013-03-18 18:19:46 +00001311 TC->SelectTool(cast<JobAction>(**Inputs->begin()));
Rafael Espindola79764462013-03-24 15:06:53 +00001312 if (!Compiler)
1313 return NULL;
1314 if (Compiler->hasIntegratedAssembler()) {
Daniel Dunbarc4343942010-02-03 03:07:56 +00001315 Inputs = &(*Inputs)[0]->getInputs();
Rafael Espindola79764462013-03-24 15:06:53 +00001316 ToolForJob = Compiler;
Daniel Dunbarc4343942010-02-03 03:07:56 +00001317 }
1318 }
1319
1320 // Otherwise use the tool for the current job.
1321 if (!ToolForJob)
Rafael Espindola79764462013-03-24 15:06:53 +00001322 ToolForJob = TC->SelectTool(*JA);
Daniel Dunbarc4343942010-02-03 03:07:56 +00001323
1324 // See if we should use an integrated preprocessor. We do so when we have
1325 // exactly one input, since this is the only use case we care about
1326 // (irrelevant since we don't support combine yet).
1327 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1328 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1329 !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1330 !C.getArgs().hasArg(options::OPT_save_temps) &&
Fariborz Jahanian659bc4a2012-09-28 19:05:17 +00001331 !C.getArgs().hasArg(options::OPT_rewrite_objc) &&
Daniel Dunbarc4343942010-02-03 03:07:56 +00001332 ToolForJob->hasIntegratedCPP())
1333 Inputs = &(*Inputs)[0]->getInputs();
1334
Rafael Espindola79764462013-03-24 15:06:53 +00001335 return ToolForJob;
Daniel Dunbarc4343942010-02-03 03:07:56 +00001336}
1337
Daniel Dunbare75d8342009-03-16 06:56:51 +00001338void Driver::BuildJobsForAction(Compilation &C,
1339 const Action *A,
1340 const ToolChain *TC,
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001341 const char *BoundArch,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001342 bool AtTopLevel,
Chad Rosier35767232013-04-30 22:01:21 +00001343 bool MultipleArchs,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001344 const char *LinkingOutput,
1345 InputInfo &Result) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001346 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbarc4acf9d2009-03-18 23:18:19 +00001347
Daniel Dunbare75d8342009-03-16 06:56:51 +00001348 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001349 // FIXME: It would be nice to not claim this here; maybe the old scheme of
1350 // just using Args was better?
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001351 const Arg &Input = IA->getInputArg();
1352 Input.claim();
Daniel Dunbar35cbfeb2010-06-09 22:31:08 +00001353 if (Input.getOption().matches(options::OPT_INPUT)) {
Richard Smithbd55daf2012-11-01 04:30:05 +00001354 const char *Name = Input.getValue();
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001355 Result = InputInfo(Name, A->getType(), Name);
1356 } else
1357 Result = InputInfo(&Input, A->getType(), "");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001358 return;
1359 }
1360
1361 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
Chad Rosiera78a6eb2012-04-27 16:50:38 +00001362 const ToolChain *TC;
Chad Rosier631fa102012-04-27 16:48:16 +00001363 const char *ArchName = BAA->getArchName();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00001364
Chad Rosier631fa102012-04-27 16:48:16 +00001365 if (ArchName)
1366 TC = &getToolChain(C.getArgs(), ArchName);
Chad Rosiera78a6eb2012-04-27 16:50:38 +00001367 else
1368 TC = &C.getDefaultToolChain();
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00001369
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001370 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
Chad Rosier35767232013-04-30 22:01:21 +00001371 AtTopLevel, MultipleArchs, LinkingOutput, Result);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001372 return;
1373 }
1374
Daniel Dunbare75d8342009-03-16 06:56:51 +00001375 const ActionList *Inputs = &A->getInputs();
Daniel Dunbarc4343942010-02-03 03:07:56 +00001376
1377 const JobAction *JA = cast<JobAction>(A);
Rafael Espindola79764462013-03-24 15:06:53 +00001378 const Tool *T = SelectToolForJob(C, TC, JA, Inputs);
1379 if (!T)
1380 return;
Daniel Dunbare75d8342009-03-16 06:56:51 +00001381
1382 // Only use pipes when there is exactly one input.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001383 InputInfoList InputInfos;
Daniel Dunbare75d8342009-03-16 06:56:51 +00001384 for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1385 it != ie; ++it) {
Eric Christopher14668dd2013-02-18 00:38:25 +00001386 // Treat dsymutil and verify sub-jobs as being at the top-level too, they
1387 // shouldn't get temporary output names.
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001388 // FIXME: Clean this up.
1389 bool SubJobAtTopLevel = false;
Eric Christopher14668dd2013-02-18 00:38:25 +00001390 if (AtTopLevel && (isa<DsymutilJobAction>(A) || isa<VerifyJobAction>(A)))
Eric Christopher551ef452011-08-23 17:56:55 +00001391 SubJobAtTopLevel = true;
1392
Daniel Dunbare75d8342009-03-16 06:56:51 +00001393 InputInfo II;
Chad Rosier35767232013-04-30 22:01:21 +00001394 BuildJobsForAction(C, *it, TC, BoundArch, SubJobAtTopLevel, MultipleArchs,
1395 LinkingOutput, II);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001396 InputInfos.push_back(II);
1397 }
1398
Daniel Dunbare75d8342009-03-16 06:56:51 +00001399 // Always use the first input as the base input.
1400 const char *BaseInput = InputInfos[0].getBaseInput();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001401
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001402 // ... except dsymutil actions, which use their actual input as the base
1403 // input.
1404 if (JA->getType() == types::TY_dSYM)
1405 BaseInput = InputInfos[0].getFilename();
1406
Daniel Dunbard00272f2010-08-02 02:38:15 +00001407 // Determine the place to write output to, if any.
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00001408 if (JA->getType() == types::TY_Nothing)
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001409 Result = InputInfo(A->getType(), BaseInput);
Eric Christopher2ba5fcb2013-02-05 07:29:57 +00001410 else
Chad Rosier35767232013-04-30 22:01:21 +00001411 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, BoundArch,
1412 AtTopLevel, MultipleArchs),
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001413 A->getType(), BaseInput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001414
Chad Rosierbe10f982011-08-02 17:58:04 +00001415 if (CCCPrintBindings && !CCGenDiagnostics) {
Rafael Espindola79764462013-03-24 15:06:53 +00001416 llvm::errs() << "# \"" << T->getToolChain().getTripleString() << '"'
1417 << " - \"" << T->getName() << "\", inputs: [";
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001418 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1419 llvm::errs() << InputInfos[i].getAsString();
1420 if (i + 1 != e)
1421 llvm::errs() << ", ";
1422 }
1423 llvm::errs() << "], output: " << Result.getAsString() << "\n";
1424 } else {
Rafael Espindola79764462013-03-24 15:06:53 +00001425 T->ConstructJob(C, *JA, Result, InputInfos,
1426 C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001427 }
Daniel Dunbare75d8342009-03-16 06:56:51 +00001428}
1429
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001430const char *Driver::GetNamedOutputPath(Compilation &C,
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001431 const JobAction &JA,
1432 const char *BaseInput,
Chad Rosier35767232013-04-30 22:01:21 +00001433 const char *BoundArch,
1434 bool AtTopLevel,
1435 bool MultipleArchs) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001436 llvm::PrettyStackTraceString CrashInfo("Computing output path");
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001437 // Output to a user requested destination?
Eric Christopher551ef452011-08-23 17:56:55 +00001438 if (AtTopLevel && !isa<DsymutilJobAction>(JA) &&
1439 !isa<VerifyJobAction>(JA)) {
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001440 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
Chad Rosier633dcdc2013-01-24 19:14:47 +00001441 return C.addResultFile(FinalOutput->getValue(), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001442 }
1443
Nick Lewycky6e1ce292010-09-24 00:46:53 +00001444 // Default to writing to stdout?
Douglas Gregorbf7fc9c2013-03-27 16:47:18 +00001445 if (AtTopLevel && !CCGenDiagnostics &&
1446 (isa<PreprocessJobAction>(JA) || JA.getType() == types::TY_ModuleFile))
Nick Lewycky6e1ce292010-09-24 00:46:53 +00001447 return "-";
1448
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001449 // Output to a temporary file?
Chad Rosierbe10f982011-08-02 17:58:04 +00001450 if ((!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) ||
1451 CCGenDiagnostics) {
Chad Rosier97c37372011-08-26 22:27:02 +00001452 StringRef Name = llvm::sys::path::filename(BaseInput);
1453 std::pair<StringRef, StringRef> Split = Name.split('.');
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001454 std::string TmpName =
Chad Rosier97c37372011-08-26 22:27:02 +00001455 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType()));
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001456 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001457 }
1458
Dylan Noblesmith2c1dd272012-02-05 02:13:05 +00001459 SmallString<128> BasePath(BaseInput);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001460 StringRef BaseName;
Daniel Dunbar67fea712011-03-25 18:16:51 +00001461
1462 // Dsymutil actions should use the full path.
Eric Christopher551ef452011-08-23 17:56:55 +00001463 if (isa<DsymutilJobAction>(JA) || isa<VerifyJobAction>(JA))
Daniel Dunbar67fea712011-03-25 18:16:51 +00001464 BaseName = BasePath;
1465 else
1466 BaseName = llvm::sys::path::filename(BasePath);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001467
1468 // Determine what the derived output name should be.
1469 const char *NamedOutput;
Chad Rosier35767232013-04-30 22:01:21 +00001470 if (JA.getType() == types::TY_Image) {
1471 if (MultipleArchs && BoundArch) {
1472 SmallString<128> Output(DefaultImageName.c_str());
1473 Output += "-";
1474 Output.append(BoundArch);
1475 NamedOutput = C.getArgs().MakeArgString(Output.c_str());
1476 } else
1477 NamedOutput = DefaultImageName.c_str();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001478 } else {
1479 const char *Suffix = types::getTypeTempSuffix(JA.getType());
1480 assert(Suffix && "All types used for output should have a suffix.");
1481
1482 std::string::size_type End = std::string::npos;
1483 if (!types::appendSuffixForType(JA.getType()))
1484 End = BaseName.rfind('.');
Chad Rosier35767232013-04-30 22:01:21 +00001485 SmallString<128> Suffixed(BaseName.substr(0, End));
1486 if (MultipleArchs && BoundArch) {
1487 Suffixed += "-";
1488 Suffixed.append(BoundArch);
1489 }
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001490 Suffixed += '.';
1491 Suffixed += Suffix;
1492 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1493 }
1494
Chad Rosier62135492012-07-09 17:31:28 +00001495 // If we're saving temps and the temp file conflicts with the input file,
Chad Rosier5b58af02012-04-20 20:05:08 +00001496 // then avoid overwriting input file.
Chad Rosierf8412cd2011-07-15 21:54:29 +00001497 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
Chad Rosier39ab7432011-08-26 21:28:44 +00001498 NamedOutput == BaseName) {
Chad Rosier5b58af02012-04-20 20:05:08 +00001499
1500 bool SameFile = false;
1501 SmallString<256> Result;
1502 llvm::sys::fs::current_path(Result);
1503 llvm::sys::path::append(Result, BaseName);
1504 llvm::sys::fs::equivalent(BaseInput, Result.c_str(), SameFile);
1505 // Must share the same path to conflict.
1506 if (SameFile) {
1507 StringRef Name = llvm::sys::path::filename(BaseInput);
1508 std::pair<StringRef, StringRef> Split = Name.split('.');
1509 std::string TmpName =
1510 GetTemporaryPath(Split.first, types::getTypeTempSuffix(JA.getType()));
1511 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1512 }
Chad Rosierf8412cd2011-07-15 21:54:29 +00001513 }
1514
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001515 // As an annoying special case, PCH generation doesn't strip the pathname.
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001516 if (JA.getType() == types::TY_PCH) {
Michael J. Spencere1696752010-12-18 00:19:12 +00001517 llvm::sys::path::remove_filename(BasePath);
1518 if (BasePath.empty())
Daniel Dunbare6c83192009-03-18 09:58:30 +00001519 BasePath = NamedOutput;
1520 else
Michael J. Spencere1696752010-12-18 00:19:12 +00001521 llvm::sys::path::append(BasePath, NamedOutput);
Chad Rosier633dcdc2013-01-24 19:14:47 +00001522 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()), &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001523 } else {
Chad Rosier633dcdc2013-01-24 19:14:47 +00001524 return C.addResultFile(NamedOutput, &JA);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001525 }
1526}
1527
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001528std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
Chandler Carruth84559242010-03-22 01:52:07 +00001529 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00001530 // attempting to use this prefix when looking for file paths.
Benjamin Kramer1a648d12011-02-08 20:31:42 +00001531 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1532 ie = PrefixDirs.end(); it != ie; ++it) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00001533 std::string Dir(*it);
1534 if (Dir.empty())
1535 continue;
1536 if (Dir[0] == '=')
1537 Dir = SysRoot + Dir.substr(1);
Rafael Espindola609a6642013-06-24 18:33:43 +00001538 SmallString<128> P(Dir);
1539 llvm::sys::path::append(P, Name);
1540 if (llvm::sys::fs::exists(Twine(P)))
Chandler Carruth84559242010-03-22 01:52:07 +00001541 return P.str();
1542 }
1543
Rafael Espindola609a6642013-06-24 18:33:43 +00001544 SmallString<128> P(ResourceDir);
1545 llvm::sys::path::append(P, Name);
1546 if (llvm::sys::fs::exists(Twine(P)))
Peter Collingbournefa9771f2011-09-06 02:08:31 +00001547 return P.str();
1548
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001549 const ToolChain::path_list &List = TC.getFilePaths();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001550 for (ToolChain::path_list::const_iterator
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001551 it = List.begin(), ie = List.end(); it != ie; ++it) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00001552 std::string Dir(*it);
1553 if (Dir.empty())
1554 continue;
1555 if (Dir[0] == '=')
1556 Dir = SysRoot + Dir.substr(1);
Rafael Espindola609a6642013-06-24 18:33:43 +00001557 SmallString<128> P(Dir);
1558 llvm::sys::path::append(P, Name);
1559 if (llvm::sys::fs::exists(Twine(P)))
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001560 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001561 }
1562
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001563 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001564}
1565
Simon Atanasyanb16488c2012-10-03 19:52:37 +00001566std::string Driver::GetProgramPath(const char *Name,
1567 const ToolChain &TC) const {
Joerg Sonnenberger17d75512012-02-22 19:15:16 +00001568 // FIXME: Needs a better variable than DefaultTargetTriple
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001569 std::string TargetSpecificExecutable(DefaultTargetTriple + "-" + Name);
Chandler Carruth84559242010-03-22 01:52:07 +00001570 // Respect a limited subset of the '-Bprefix' functionality in GCC by
Logan Chiencd679fd2012-10-04 08:08:56 +00001571 // attempting to use this prefix when looking for program paths.
Benjamin Kramer1a648d12011-02-08 20:31:42 +00001572 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1573 ie = PrefixDirs.end(); it != ie; ++it) {
Simon Atanasyan86bdab72012-10-31 12:01:53 +00001574 bool IsDirectory;
1575 if (!llvm::sys::fs::is_directory(*it, IsDirectory) && IsDirectory) {
Rafael Espindola609a6642013-06-24 18:33:43 +00001576 SmallString<128> P(*it);
1577 llvm::sys::path::append(P, TargetSpecificExecutable);
1578 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00001579 return P.str();
Rafael Espindola609a6642013-06-24 18:33:43 +00001580 llvm::sys::path::remove_filename(P);
1581 llvm::sys::path::append(P, Name);
1582 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00001583 return P.str();
Simon Atanasyana47ba292012-10-31 14:39:28 +00001584 } else {
Rafael Espindola609a6642013-06-24 18:33:43 +00001585 SmallString<128> P(*it + Name);
1586 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00001587 return P.str();
Simon Atanasyan86bdab72012-10-31 12:01:53 +00001588 }
Chandler Carruth84559242010-03-22 01:52:07 +00001589 }
1590
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001591 const ToolChain::path_list &List = TC.getProgramPaths();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001592 for (ToolChain::path_list::const_iterator
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001593 it = List.begin(), ie = List.end(); it != ie; ++it) {
Rafael Espindola609a6642013-06-24 18:33:43 +00001594 SmallString<128> P(*it);
1595 llvm::sys::path::append(P, TargetSpecificExecutable);
1596 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00001597 return P.str();
Rafael Espindola609a6642013-06-24 18:33:43 +00001598 llvm::sys::path::remove_filename(P);
1599 llvm::sys::path::append(P, Name);
1600 if (llvm::sys::fs::can_execute(Twine(P)))
Rafael Espindola8be5c052013-06-19 13:24:29 +00001601 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001602 }
1603
Daniel Dunbar76ce7412009-03-23 16:15:50 +00001604 // If all else failed, search the path.
Rafael Espindola609a6642013-06-24 18:33:43 +00001605 std::string P(llvm::sys::FindProgramByName(TargetSpecificExecutable));
David Chisnallddbd68f2011-09-27 22:03:18 +00001606 if (!P.empty())
Rafael Espindola609a6642013-06-24 18:33:43 +00001607 return P;
David Chisnallddbd68f2011-09-27 22:03:18 +00001608
Rafael Espindola609a6642013-06-24 18:33:43 +00001609 P = llvm::sys::FindProgramByName(Name);
Daniel Dunbar6f668772009-03-18 21:34:08 +00001610 if (!P.empty())
Rafael Espindola609a6642013-06-24 18:33:43 +00001611 return P;
Daniel Dunbar6f668772009-03-18 21:34:08 +00001612
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001613 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001614}
1615
Chad Rosier62135492012-07-09 17:31:28 +00001616std::string Driver::GetTemporaryPath(StringRef Prefix, const char *Suffix)
Chad Rosier39ab7432011-08-26 21:28:44 +00001617 const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001618 // FIXME: This is lame; sys::Path should provide this function (in particular,
1619 // it should know how to find the temporary files dir).
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001620 std::string Error;
Daniel Dunbarc35694d2009-04-20 20:28:21 +00001621 const char *TmpDir = ::getenv("TMPDIR");
1622 if (!TmpDir)
1623 TmpDir = ::getenv("TEMP");
1624 if (!TmpDir)
Daniel Dunbar712e4de2009-04-21 00:25:10 +00001625 TmpDir = ::getenv("TMP");
1626 if (!TmpDir)
Daniel Dunbarc35694d2009-04-20 20:28:21 +00001627 TmpDir = "/tmp";
1628 llvm::sys::Path P(TmpDir);
Chad Rosier39ab7432011-08-26 21:28:44 +00001629 P.appendComponent(Prefix);
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001630 if (P.makeUnique(false, &Error)) {
Manuel Klimek3ef9c442012-05-16 20:55:58 +00001631 Diag(clang::diag::err_unable_to_make_temp) << Error;
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001632 return "";
1633 }
1634
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001635 // FIXME: Grumble, makeUnique sometimes leaves the file around!? PR3837.
Daniel Dunbar18d69de2009-03-18 23:08:52 +00001636 P.eraseFromDisk(false, 0);
1637
Ted Kremenek34556ff2012-08-07 00:02:30 +00001638 if (Suffix)
1639 P.appendSuffix(Suffix);
Chris Lattner3441b4f2009-08-23 22:45:33 +00001640 return P.str();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001641}
1642
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001643/// \brief Compute target triple from args.
1644///
1645/// This routine provides the logic to compute a target triple from various
1646/// args passed to the driver and the default triple string.
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001647static llvm::Triple computeTargetTriple(StringRef DefaultTargetTriple,
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001648 const ArgList &Args,
1649 StringRef DarwinArchName) {
Joerg Sonnenberger17d75512012-02-22 19:15:16 +00001650 // FIXME: Already done in Compilation *Driver::BuildCompilation
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001651 if (const Arg *A = Args.getLastArg(options::OPT_target))
Richard Smithbd55daf2012-11-01 04:30:05 +00001652 DefaultTargetTriple = A->getValue();
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001653
1654 llvm::Triple Target(llvm::Triple::normalize(DefaultTargetTriple));
Chris Lattner09797542010-03-04 21:07:38 +00001655
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001656 // Handle Darwin-specific options available here.
1657 if (Target.isOSDarwin()) {
1658 // If an explict Darwin arch name is given, that trumps all.
1659 if (!DarwinArchName.empty()) {
1660 Target.setArch(
Rafael Espindoladcbf6982012-10-31 18:51:07 +00001661 tools::darwin::getArchTypeForDarwinArchName(DarwinArchName));
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001662 return Target;
1663 }
1664
1665 // Handle the Darwin '-arch' flag.
1666 if (Arg *A = Args.getLastArg(options::OPT_arch)) {
1667 llvm::Triple::ArchType DarwinArch
Richard Smithbd55daf2012-11-01 04:30:05 +00001668 = tools::darwin::getArchTypeForDarwinArchName(A->getValue());
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001669 if (DarwinArch != llvm::Triple::UnknownArch)
1670 Target.setArch(DarwinArch);
1671 }
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001672 }
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001673
Simon Atanasyan66ceaa42013-03-28 11:36:22 +00001674 // Handle pseudo-target flags '-EL' and '-EB'.
1675 if (Arg *A = Args.getLastArg(options::OPT_EL, options::OPT_EB)) {
1676 if (A->getOption().matches(options::OPT_EL)) {
1677 if (Target.getArch() == llvm::Triple::mips)
1678 Target.setArch(llvm::Triple::mipsel);
1679 else if (Target.getArch() == llvm::Triple::mips64)
1680 Target.setArch(llvm::Triple::mips64el);
1681 } else {
1682 if (Target.getArch() == llvm::Triple::mipsel)
1683 Target.setArch(llvm::Triple::mips);
1684 else if (Target.getArch() == llvm::Triple::mips64el)
1685 Target.setArch(llvm::Triple::mips64);
1686 }
1687 }
1688
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001689 // Skip further flag support on OSes which don't support '-m32' or '-m64'.
1690 if (Target.getArchName() == "tce" ||
1691 Target.getOS() == llvm::Triple::AuroraUX ||
1692 Target.getOS() == llvm::Triple::Minix)
1693 return Target;
1694
1695 // Handle pseudo-target flags '-m32' and '-m64'.
1696 // FIXME: Should this information be in llvm::Triple?
1697 if (Arg *A = Args.getLastArg(options::OPT_m32, options::OPT_m64)) {
1698 if (A->getOption().matches(options::OPT_m32)) {
1699 if (Target.getArch() == llvm::Triple::x86_64)
1700 Target.setArch(llvm::Triple::x86);
1701 if (Target.getArch() == llvm::Triple::ppc64)
1702 Target.setArch(llvm::Triple::ppc);
1703 } else {
1704 if (Target.getArch() == llvm::Triple::x86)
1705 Target.setArch(llvm::Triple::x86_64);
1706 if (Target.getArch() == llvm::Triple::ppc)
1707 Target.setArch(llvm::Triple::ppc64);
1708 }
1709 }
1710
1711 return Target;
1712}
1713
1714const ToolChain &Driver::getToolChain(const ArgList &Args,
1715 StringRef DarwinArchName) const {
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001716 llvm::Triple Target = computeTargetTriple(DefaultTargetTriple, Args,
1717 DarwinArchName);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001718
Chandler Carruthd7fa2e02012-01-31 02:21:20 +00001719 ToolChain *&TC = ToolChains[Target.str()];
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001720 if (!TC) {
1721 switch (Target.getOS()) {
1722 case llvm::Triple::AuroraUX:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001723 TC = new toolchains::AuroraUX(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001724 break;
1725 case llvm::Triple::Darwin:
1726 case llvm::Triple::MacOSX:
1727 case llvm::Triple::IOS:
1728 if (Target.getArch() == llvm::Triple::x86 ||
1729 Target.getArch() == llvm::Triple::x86_64 ||
1730 Target.getArch() == llvm::Triple::arm ||
1731 Target.getArch() == llvm::Triple::thumb)
Rafael Espindola84b588b2013-03-18 18:10:27 +00001732 TC = new toolchains::DarwinClang(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001733 else
Rafael Espindola1af7c212012-02-19 01:38:32 +00001734 TC = new toolchains::Darwin_Generic_GCC(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001735 break;
1736 case llvm::Triple::DragonFly:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001737 TC = new toolchains::DragonFly(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001738 break;
1739 case llvm::Triple::OpenBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001740 TC = new toolchains::OpenBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001741 break;
Eli Friedman9fa28852012-08-08 23:57:20 +00001742 case llvm::Triple::Bitrig:
1743 TC = new toolchains::Bitrig(*this, Target, Args);
1744 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001745 case llvm::Triple::NetBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001746 TC = new toolchains::NetBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001747 break;
1748 case llvm::Triple::FreeBSD:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001749 TC = new toolchains::FreeBSD(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001750 break;
1751 case llvm::Triple::Minix:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001752 TC = new toolchains::Minix(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001753 break;
1754 case llvm::Triple::Linux:
Chandler Carruthcf705b22012-01-25 21:03:58 +00001755 if (Target.getArch() == llvm::Triple::hexagon)
Matthew Curtis22dd8da2012-12-06 12:43:18 +00001756 TC = new toolchains::Hexagon_TC(*this, Target, Args);
Chandler Carruthcf705b22012-01-25 21:03:58 +00001757 else
Rafael Espindola1af7c212012-02-19 01:38:32 +00001758 TC = new toolchains::Linux(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001759 break;
David Chisnallf571cde2012-02-15 13:39:01 +00001760 case llvm::Triple::Solaris:
Rafael Espindola1af7c212012-02-19 01:38:32 +00001761 TC = new toolchains::Solaris(*this, Target, Args);
David Chisnallf571cde2012-02-15 13:39:01 +00001762 break;
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001763 case llvm::Triple::Win32:
Rafael Espindola84b588b2013-03-18 18:10:27 +00001764 TC = new toolchains::Windows(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001765 break;
1766 case llvm::Triple::MinGW32:
1767 // FIXME: We need a MinGW toolchain. Fallthrough for now.
1768 default:
1769 // TCE is an OSless target
1770 if (Target.getArchName() == "tce") {
Rafael Espindola84b588b2013-03-18 18:10:27 +00001771 TC = new toolchains::TCEToolChain(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001772 break;
1773 }
Jyotsna Verma3abdf1c2013-03-29 19:09:20 +00001774 // If Hexagon is configured as an OSless target
1775 if (Target.getArch() == llvm::Triple::hexagon) {
1776 TC = new toolchains::Hexagon_TC(*this, Target, Args);
1777 break;
1778 }
Rafael Espindola1af7c212012-02-19 01:38:32 +00001779 TC = new toolchains::Generic_GCC(*this, Target, Args);
Chandler Carruth2ad5de12012-01-25 11:01:57 +00001780 break;
1781 }
1782 }
1783 return *TC;
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00001784}
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001785
Rafael Espindola2f69d402013-03-18 15:33:26 +00001786bool Driver::ShouldUseClangCompiler(const JobAction &JA) const {
Nick Lewycky5cc9ebb2012-11-15 05:36:36 +00001787 // Check if user requested no clang, or clang doesn't understand this type (we
1788 // only handle single inputs for now).
1789 if (JA.size() != 1 ||
1790 !types::isAcceptedByClang((*JA.begin())->getType()))
1791 return false;
1792
1793 // Otherwise make sure this is an action clang understands.
1794 if (!isa<PreprocessJobAction>(JA) && !isa<PrecompileJobAction>(JA) &&
1795 !isa<CompileJobAction>(JA))
1796 return false;
1797
1798 return true;
1799}
1800
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001801/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1802/// grouped values as integers. Numbers which are not provided are set to 0.
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001803///
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001804/// \return True if the entire string was parsed (9.2), or all groups were
1805/// parsed (10.3.5extrastuff).
1806bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001807 unsigned &Minor, unsigned &Micro,
1808 bool &HadExtra) {
1809 HadExtra = false;
1810
1811 Major = Minor = Micro = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001812 if (*Str == '\0')
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001813 return true;
1814
1815 char *End;
1816 Major = (unsigned) strtol(Str, &End, 10);
1817 if (*Str != '\0' && *End == '\0')
1818 return true;
1819 if (*End != '.')
1820 return false;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001821
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001822 Str = End+1;
1823 Minor = (unsigned) strtol(Str, &End, 10);
1824 if (*Str != '\0' && *End == '\0')
1825 return true;
1826 if (*End != '.')
1827 return false;
1828
1829 Str = End+1;
1830 Micro = (unsigned) strtol(Str, &End, 10);
1831 if (*Str != '\0' && *End == '\0')
1832 return true;
1833 if (Str == End)
1834 return false;
1835 HadExtra = true;
1836 return true;
1837}