blob: ac5cedf7719e77a65672bed7970279f5db355374 [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
Oscar Fuentesedeaf162011-02-03 22:48:20 +000010#ifdef HAVE_CLANG_CONFIG_H
11# include "clang/Config/config.h"
12#endif
13
Daniel Dunbar544ecd12009-03-02 19:59:07 +000014#include "clang/Driver/Driver.h"
Daniel Dunbar544ecd12009-03-02 19:59:07 +000015
Daniel Dunbar1688f1a2009-03-12 07:58:46 +000016#include "clang/Driver/Action.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000017#include "clang/Driver/Arg.h"
18#include "clang/Driver/ArgList.h"
19#include "clang/Driver/Compilation.h"
Daniel Dunbarc0b3e952009-03-12 08:55:43 +000020#include "clang/Driver/DriverDiagnostic.h"
Daniel Dunbar4dff6a42009-03-10 23:41:59 +000021#include "clang/Driver/HostInfo.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000022#include "clang/Driver/Job.h"
Daniel Dunbaraa767372009-11-19 00:15:11 +000023#include "clang/Driver/OptTable.h"
Daniel Dunbard02cb1d2009-03-05 06:38:47 +000024#include "clang/Driver/Option.h"
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000025#include "clang/Driver/Options.h"
Daniel Dunbare75d8342009-03-16 06:56:51 +000026#include "clang/Driver/Tool.h"
27#include "clang/Driver/ToolChain.h"
Daniel Dunbar1688f1a2009-03-12 07:58:46 +000028#include "clang/Driver/Types.h"
Daniel Dunbard02cb1d2009-03-05 06:38:47 +000029
Douglas Gregor7b71e632009-04-27 22:23:34 +000030#include "clang/Basic/Version.h"
31
Daniel Dunbar628fcf42010-08-12 00:05:12 +000032#include "llvm/Config/config.h"
Chris Lattnerce6c42f2011-03-23 04:04:01 +000033#include "llvm/ADT/ArrayRef.h"
Daniel Dunbare5dc4822009-03-13 20:33:35 +000034#include "llvm/ADT/StringSet.h"
Ted Kremenekbb1110a2010-01-19 01:29:05 +000035#include "llvm/ADT/OwningPtr.h"
Daniel Dunbar2608c542009-03-18 01:38:48 +000036#include "llvm/Support/PrettyStackTrace.h"
Daniel Dunbard02cb1d2009-03-05 06:38:47 +000037#include "llvm/Support/raw_ostream.h"
Michael J. Spencerf28df4c2010-12-17 21:22:22 +000038#include "llvm/Support/FileSystem.h"
Michael J. Spencer8aaf4992010-11-29 18:12:39 +000039#include "llvm/Support/Path.h"
40#include "llvm/Support/Program.h"
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +000041
Daniel Dunbare75d8342009-03-16 06:56:51 +000042#include "InputInfo.h"
43
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +000044#include <map>
45
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000046using namespace clang::driver;
Chris Lattnerada1c912009-03-26 05:56:24 +000047using namespace clang;
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000048
Chris Lattner0e62c1c2011-07-23 10:55:15 +000049Driver::Driver(StringRef ClangExecutable,
50 StringRef DefaultHostTriple,
51 StringRef DefaultImageName,
Daniel Dunbare43887b2010-04-01 18:21:41 +000052 bool IsProduction, bool CXXIsProduction,
Nick Lewycky62188bb2011-06-04 05:19:42 +000053 Diagnostic &Diags)
54 : Opts(createDriverOptTable()), Diags(Diags),
55 ClangExecutable(ClangExecutable), UseStdLib(true),
56 DefaultHostTriple(DefaultHostTriple), DefaultImageName(DefaultImageName),
Daniel Dunbar3babf5d2010-02-25 03:31:53 +000057 DriverTitle("clang \"gcc-compatible\" driver"),
Daniel Dunbar4dff6a42009-03-10 23:41:59 +000058 Host(0),
Daniel Dunbar529c03b2011-04-07 18:01:20 +000059 CCPrintOptionsFilename(0), CCPrintHeadersFilename(0),
60 CCLogDiagnosticsFilename(0), CCCIsCXX(false),
Joerg Sonnenberger9c8ad5f2011-03-07 00:09:32 +000061 CCCIsCPP(false),CCCEcho(false), CCCPrintBindings(false),
Daniel Dunbar529c03b2011-04-07 18:01:20 +000062 CCPrintOptions(false), CCPrintHeaders(false), CCLogDiagnostics(false),
Chad Rosier19886422011-07-20 21:16:17 +000063 CCCGenericGCCName(""), CheckInputsExist(true), CCCUseClang(true),
64 CCCUseClangCXX(true), CCCUseClangCPP(true), CCCUsePCH(true),
65 SuppressMissingInputWarning(false) {
Daniel Dunbar5564ba72009-09-22 22:31:13 +000066 if (IsProduction) {
67 // In a "production" build, only use clang on architectures we expect to
68 // work, and don't use clang C++.
69 //
70 // During development its more convenient to always have the driver use
71 // clang, but we don't want users to be confused when things don't work, or
72 // to file bugs for things we don't support.
73 CCCClangArchs.insert(llvm::Triple::x86);
74 CCCClangArchs.insert(llvm::Triple::x86_64);
75 CCCClangArchs.insert(llvm::Triple::arm);
76
Daniel Dunbare43887b2010-04-01 18:21:41 +000077 if (!CXXIsProduction)
78 CCCUseClangCXX = false;
Daniel Dunbar5564ba72009-09-22 22:31:13 +000079 }
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +000080
Michael J. Spencere47230f2010-12-18 04:13:32 +000081 Name = llvm::sys::path::stem(ClangExecutable);
82 Dir = llvm::sys::path::parent_path(ClangExecutable);
Daniel Dunbare38764c2010-07-19 00:44:04 +000083
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +000084 // Compute the path to the resource directory.
Chris Lattner0e62c1c2011-07-23 10:55:15 +000085 StringRef ClangResourceDir(CLANG_RESOURCE_DIR);
Michael J. Spencere47230f2010-12-18 04:13:32 +000086 llvm::SmallString<128> P(Dir);
87 if (ClangResourceDir != "")
88 llvm::sys::path::append(P, ClangResourceDir);
89 else
90 llvm::sys::path::append(P, "..", "lib", "clang", CLANG_VERSION_STRING);
Daniel Dunbar3f3e2cd2010-01-20 02:35:16 +000091 ResourceDir = P.str();
Daniel Dunbar544ecd12009-03-02 19:59:07 +000092}
93
94Driver::~Driver() {
Daniel Dunbarb2cd66b2009-03-04 20:49:20 +000095 delete Opts;
Daniel Dunbar01601722009-03-18 01:09:40 +000096 delete Host;
Daniel Dunbar544ecd12009-03-02 19:59:07 +000097}
98
Chris Lattner54b16772011-07-23 17:14:25 +000099InputArgList *Driver::ParseArgStrings(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000100 llvm::PrettyStackTraceString CrashInfo("Command line argument parsing");
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000101 unsigned MissingArgIndex, MissingArgCount;
Chris Lattnerce6c42f2011-03-23 04:04:01 +0000102 InputArgList *Args = getOpts().ParseArgs(ArgList.begin(), ArgList.end(),
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000103 MissingArgIndex, MissingArgCount);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000104
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000105 // Check for missing argument error.
106 if (MissingArgCount)
107 Diag(clang::diag::err_drv_missing_argument)
108 << Args->getArgString(MissingArgIndex) << MissingArgCount;
Daniel Dunbar65229332009-03-13 11:38:42 +0000109
Daniel Dunbar52ed5fe2009-11-19 06:35:06 +0000110 // Check for unsupported options.
111 for (ArgList::const_iterator it = Args->begin(), ie = Args->end();
112 it != ie; ++it) {
113 Arg *A = *it;
Daniel Dunbard8500f32009-03-22 23:26:43 +0000114 if (A->getOption().isUnsupported()) {
115 Diag(clang::diag::err_drv_unsupported_opt) << A->getAsString(*Args);
116 continue;
117 }
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000118 }
119
120 return Args;
121}
122
Chad Rosier7742b5d2011-07-27 23:36:45 +0000123// Determine which compilation mode we are in. We look for options which
124// affect the phase, starting with the earliest phases, and record which
125// option we used to determine the final phase.
126phases::ID Driver::getFinalPhase(const DerivedArgList &DAL, Arg **FinalPhaseArg)
127const {
128 Arg *PhaseArg = 0;
129 phases::ID FinalPhase;
130
131 // -{E,M,MM} only run the preprocessor.
132 if (CCCIsCPP ||
133 (PhaseArg = DAL.getLastArg(options::OPT_E)) ||
134 (PhaseArg = DAL.getLastArg(options::OPT_M, options::OPT_MM))) {
135 FinalPhase = phases::Preprocess;
136
137 // -{fsyntax-only,-analyze,emit-ast,S} only run up to the compiler.
138 } else if ((PhaseArg = DAL.getLastArg(options::OPT_fsyntax_only)) ||
139 (PhaseArg = DAL.getLastArg(options::OPT_rewrite_objc)) ||
140 (PhaseArg = DAL.getLastArg(options::OPT__analyze,
141 options::OPT__analyze_auto)) ||
142 (PhaseArg = DAL.getLastArg(options::OPT_emit_ast)) ||
143 (PhaseArg = DAL.getLastArg(options::OPT_S))) {
144 FinalPhase = phases::Compile;
145
146 // -c only runs up to the assembler.
147 } else if ((PhaseArg = DAL.getLastArg(options::OPT_c))) {
148 FinalPhase = phases::Assemble;
149
150 // Otherwise do everything.
151 } else
152 FinalPhase = phases::Link;
153
154 if (FinalPhaseArg)
155 *FinalPhaseArg = PhaseArg;
156
157 return FinalPhase;
158}
159
Daniel Dunbar775d4062010-06-11 22:00:26 +0000160DerivedArgList *Driver::TranslateInputArgs(const InputArgList &Args) const {
161 DerivedArgList *DAL = new DerivedArgList(Args);
162
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000163 bool HasNostdlib = Args.hasArg(options::OPT_nostdlib);
Daniel Dunbar775d4062010-06-11 22:00:26 +0000164 for (ArgList::const_iterator it = Args.begin(),
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000165 ie = Args.end(); it != ie; ++it) {
166 const Arg *A = *it;
167
168 // Unfortunately, we have to parse some forwarding options (-Xassembler,
169 // -Xlinker, -Xpreprocessor) because we either integrate their functionality
170 // (assembler and preprocessor), or bypass a previous driver ('collect2').
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000171
172 // Rewrite linker options, to replace --no-demangle with a custom internal
173 // option.
174 if ((A->getOption().matches(options::OPT_Wl_COMMA) ||
175 A->getOption().matches(options::OPT_Xlinker)) &&
176 A->containsValue("--no-demangle")) {
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000177 // Add the rewritten no-demangle argument.
178 DAL->AddFlagArg(A, Opts->getOption(options::OPT_Z_Xlinker__no_demangle));
179
180 // Add the remaining values as Xlinker arguments.
181 for (unsigned i = 0, e = A->getNumValues(); i != e; ++i)
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000182 if (StringRef(A->getValue(Args, i)) != "--no-demangle")
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000183 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_Xlinker),
184 A->getValue(Args, i));
185
186 continue;
187 }
188
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000189 // Rewrite preprocessor options, to replace -Wp,-MD,FOO which is used by
190 // some build systems. We don't try to be complete here because we don't
191 // care to encourage this usage model.
192 if (A->getOption().matches(options::OPT_Wp_COMMA) &&
193 A->getNumValues() == 2 &&
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000194 (A->getValue(Args, 0) == StringRef("-MD") ||
195 A->getValue(Args, 0) == StringRef("-MMD"))) {
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000196 // Rewrite to -MD/-MMD along with -MF.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000197 if (A->getValue(Args, 0) == StringRef("-MD"))
Daniel Dunbar3648ba72010-06-15 20:30:18 +0000198 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MD));
199 else
200 DAL->AddFlagArg(A, Opts->getOption(options::OPT_MMD));
Daniel Dunbar5a9d1832010-06-14 21:37:09 +0000201 DAL->AddSeparateArg(A, Opts->getOption(options::OPT_MF),
202 A->getValue(Args, 1));
203 continue;
204 }
205
Shantonu Senafeb03b2010-09-17 18:39:08 +0000206 // Rewrite reserved library names.
207 if (A->getOption().matches(options::OPT_l)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000208 StringRef Value = A->getValue(Args);
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000209
Shantonu Senafeb03b2010-09-17 18:39:08 +0000210 // Rewrite unless -nostdlib is present.
211 if (!HasNostdlib && Value == "stdc++") {
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000212 DAL->AddFlagArg(A, Opts->getOption(
213 options::OPT_Z_reserved_lib_stdcxx));
214 continue;
215 }
Shantonu Senafeb03b2010-09-17 18:39:08 +0000216
217 // Rewrite unconditionally.
218 if (Value == "cc_kext") {
219 DAL->AddFlagArg(A, Opts->getOption(
220 options::OPT_Z_reserved_lib_cckext));
221 continue;
222 }
Daniel Dunbar2cc3f172010-09-17 00:45:02 +0000223 }
224
Daniel Dunbar775d4062010-06-11 22:00:26 +0000225 DAL->append(*it);
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000226 }
Daniel Dunbar775d4062010-06-11 22:00:26 +0000227
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000228 // Add a default value of -mlinker-version=, if one was given and the user
229 // didn't specify one.
230#if defined(HOST_LINK_VERSION)
231 if (!Args.hasArg(options::OPT_mlinker_version_EQ)) {
232 DAL->AddJoinedArg(0, Opts->getOption(options::OPT_mlinker_version_EQ),
233 HOST_LINK_VERSION);
Daniel Dunbarb613ffc2010-08-17 22:32:45 +0000234 DAL->getLastArg(options::OPT_mlinker_version_EQ)->claim();
Daniel Dunbar628fcf42010-08-12 00:05:12 +0000235 }
236#endif
237
Chad Rosier7742b5d2011-07-27 23:36:45 +0000238 // If -fapple-kext has been specified, add -kext to linker command if not
239 // already done so. Also check to make sure we're actually linking.
240 if (Args.hasArg(options::OPT_fapple_kext) && getFinalPhase(*DAL) ==
241 phases::Link) {
242 bool add_kext = true;
243 std::vector<std::string> LinkerArgs =
244 Args.getAllArgValues(options::OPT_Xlinker);
245 for (std::vector<std::string>::iterator it = LinkerArgs.begin(),
246 ie = LinkerArgs.end(); it != ie; it++)
247 if (*it == "-kext") {
248 add_kext = false;
249 break;
250 }
251 if (add_kext)
252 DAL->AddSeparateArg(0, Opts->getOption(options::OPT_Xlinker), "-kext");
253 }
254
Daniel Dunbar775d4062010-06-11 22:00:26 +0000255 return DAL;
256}
257
Chris Lattner54b16772011-07-23 17:14:25 +0000258Compilation *Driver::BuildCompilation(ArrayRef<const char *> ArgList) {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000259 llvm::PrettyStackTraceString CrashInfo("Compilation construction");
260
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000261 // FIXME: Handle environment options which effect driver behavior, somewhere
262 // (client?). GCC_EXEC_PREFIX, COMPILER_PATH, LIBRARY_PATH, LPATH,
263 // CC_PRINT_OPTIONS.
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000264
265 // FIXME: What are we going to do with -V and -b?
266
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000267 // FIXME: This stuff needs to go into the Compilation, not the driver.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000268 bool CCCPrintOptions = false, CCCPrintActions = false;
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000269
Chris Lattnerce6c42f2011-03-23 04:04:01 +0000270 InputArgList *Args = ParseArgStrings(ArgList.slice(1));
Daniel Dunbaracd69572009-12-04 21:55:23 +0000271
Rafael Espindola59ae7992009-12-07 18:28:29 +0000272 // -no-canonical-prefixes is used very early in main.
273 Args->ClaimAllArgs(options::OPT_no_canonical_prefixes);
274
Daniel Dunbar926f81f2010-08-02 02:38:03 +0000275 // Ignore -pipe.
276 Args->ClaimAllArgs(options::OPT_pipe);
277
Daniel Dunbaracd69572009-12-04 21:55:23 +0000278 // Extract -ccc args.
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000279 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000280 // FIXME: We need to figure out where this behavior should live. Most of it
281 // should be outside in the client; the parts that aren't should have proper
282 // options, either by introducing new ones or by overloading gcc ones like -V
283 // or -b.
Daniel Dunbaracd69572009-12-04 21:55:23 +0000284 CCCPrintOptions = Args->hasArg(options::OPT_ccc_print_options);
285 CCCPrintActions = Args->hasArg(options::OPT_ccc_print_phases);
286 CCCPrintBindings = Args->hasArg(options::OPT_ccc_print_bindings);
Daniel Dunbar1b52d8c2009-12-05 00:13:59 +0000287 CCCIsCXX = Args->hasArg(options::OPT_ccc_cxx) || CCCIsCXX;
Daniel Dunbaracd69572009-12-04 21:55:23 +0000288 CCCEcho = Args->hasArg(options::OPT_ccc_echo);
289 if (const Arg *A = Args->getLastArg(options::OPT_ccc_gcc_name))
290 CCCGenericGCCName = A->getValue(*Args);
291 CCCUseClangCXX = Args->hasFlag(options::OPT_ccc_clang_cxx,
Daniel Dunbar1b52d8c2009-12-05 00:13:59 +0000292 options::OPT_ccc_no_clang_cxx,
293 CCCUseClangCXX);
Daniel Dunbaracd69572009-12-04 21:55:23 +0000294 CCCUsePCH = Args->hasFlag(options::OPT_ccc_pch_is_pch,
295 options::OPT_ccc_pch_is_pth);
296 CCCUseClang = !Args->hasArg(options::OPT_ccc_no_clang);
297 CCCUseClangCPP = !Args->hasArg(options::OPT_ccc_no_clang_cpp);
298 if (const Arg *A = Args->getLastArg(options::OPT_ccc_clang_archs)) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000299 StringRef Cur = A->getValue(*Args);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000300
Daniel Dunbaracd69572009-12-04 21:55:23 +0000301 CCCClangArchs.clear();
302 while (!Cur.empty()) {
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000303 std::pair<StringRef, StringRef> Split = Cur.split(',');
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000304
Daniel Dunbaracd69572009-12-04 21:55:23 +0000305 if (!Split.first.empty()) {
306 llvm::Triple::ArchType Arch =
307 llvm::Triple(Split.first, "", "").getArch();
Daniel Dunbar7803c952009-04-01 23:34:41 +0000308
Daniel Dunbar84f22f92010-02-11 03:16:07 +0000309 if (Arch == llvm::Triple::UnknownArch)
310 Diag(clang::diag::err_drv_invalid_arch_name) << Split.first;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000311
Daniel Dunbaracd69572009-12-04 21:55:23 +0000312 CCCClangArchs.insert(Arch);
Daniel Dunbar953b8d12009-09-08 23:36:55 +0000313 }
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000314
Daniel Dunbaracd69572009-12-04 21:55:23 +0000315 Cur = Split.second;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000316 }
317 }
Daniel Dunbara73a9842010-08-02 05:44:04 +0000318 // FIXME: We shouldn't overwrite the default host triple here, but we have
319 // nowhere else to put this currently.
Daniel Dunbaracd69572009-12-04 21:55:23 +0000320 if (const Arg *A = Args->getLastArg(options::OPT_ccc_host_triple))
Daniel Dunbara73a9842010-08-02 05:44:04 +0000321 DefaultHostTriple = A->getValue(*Args);
Daniel Dunbaracd69572009-12-04 21:55:23 +0000322 if (const Arg *A = Args->getLastArg(options::OPT_ccc_install_dir))
Daniel Dunbar5d3b70a2010-08-23 20:58:50 +0000323 Dir = InstalledDir = A->getValue(*Args);
Benjamin Kramer1a648d12011-02-08 20:31:42 +0000324 for (arg_iterator it = Args->filtered_begin(options::OPT_B),
325 ie = Args->filtered_end(); it != ie; ++it) {
326 const Arg *A = *it;
327 A->claim();
328 PrefixDirs.push_back(A->getValue(*Args, 0));
329 }
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +0000330 if (const Arg *A = Args->getLastArg(options::OPT__sysroot_EQ))
331 SysRoot = A->getValue(*Args);
Joerg Sonnenbergerbc923f32011-03-21 13:59:26 +0000332 if (Args->hasArg(options::OPT_nostdlib))
333 UseStdLib = false;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000334
Daniel Dunbara73a9842010-08-02 05:44:04 +0000335 Host = GetHostInfo(DefaultHostTriple.c_str());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000336
Daniel Dunbar775d4062010-06-11 22:00:26 +0000337 // Perform the default argument translations.
338 DerivedArgList *TranslatedArgs = TranslateInputArgs(*Args);
339
Daniel Dunbar3ce436d2009-03-16 06:42:30 +0000340 // The compilation takes ownership of Args.
Daniel Dunbar775d4062010-06-11 22:00:26 +0000341 Compilation *C = new Compilation(*this, *Host->CreateToolChain(*Args), Args,
342 TranslatedArgs);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000343
344 // FIXME: This behavior shouldn't be here.
345 if (CCCPrintOptions) {
Daniel Dunbaraf8decb2010-06-11 22:43:38 +0000346 PrintOptions(C->getInputArgs());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000347 return C;
348 }
349
350 if (!HandleImmediateArgs(*C))
351 return C;
352
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000353 // Construct the list of abstract actions to perform for this compilation.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000354 if (Host->useDriverDriver())
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000355 BuildUniversalActions(C->getDefaultToolChain(), C->getArgs(),
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000356 C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000357 else
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000358 BuildActions(C->getDefaultToolChain(), C->getArgs(), C->getActions());
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000359
360 if (CCCPrintActions) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000361 PrintActions(*C);
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000362 return C;
363 }
364
365 BuildJobs(*C);
Daniel Dunbaradc91e62009-03-15 01:38:15 +0000366
367 return C;
Daniel Dunbaree66cf22009-03-10 20:52:46 +0000368}
369
Chad Rosier19886422011-07-20 21:16:17 +0000370int Driver::ExecuteCompilation(const Compilation &C) const {
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000371 // Just print if -### was present.
372 if (C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
373 C.PrintJob(llvm::errs(), C.getJobs(), "\n", true);
374 return 0;
375 }
376
377 // If there were errors building the compilation, quit now.
Chad Rosier19886422011-07-20 21:16:17 +0000378 if (getDiags().hasErrorOccurred())
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000379 return 1;
380
Chad Rosier19886422011-07-20 21:16:17 +0000381 const Command *FailingCommand = 0;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000382 int Res = C.ExecuteJob(C.getJobs(), FailingCommand);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000383
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000384 // Remove temp files.
385 C.CleanupFileList(C.getTempFiles());
386
Daniel Dunbar07494792010-05-22 00:37:20 +0000387 // If the command succeeded, we are done.
388 if (Res == 0)
389 return Res;
390
391 // Otherwise, remove result files as well.
392 if (!C.getArgs().hasArg(options::OPT_save_temps))
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000393 C.CleanupFileList(C.getResultFiles(), true);
394
395 // Print extra information about abnormal failures, if possible.
Daniel Dunbar07494792010-05-22 00:37:20 +0000396 //
397 // This is ad-hoc, but we don't want to be excessively noisy. If the result
398 // status was 1, assume the command failed normally. In particular, if it was
399 // the compiler then assume it gave a reasonable error code. Failures in other
400 // tools are less common, and they generally have worse diagnostics, so always
401 // print the diagnostic there.
402 const Tool &FailingTool = FailingCommand->getCreator();
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000403
Daniel Dunbar07494792010-05-22 00:37:20 +0000404 if (!FailingCommand->getCreator().hasGoodDiagnostics() || Res != 1) {
405 // FIXME: See FIXME above regarding result code interpretation.
406 if (Res < 0)
407 Diag(clang::diag::err_drv_command_signalled)
408 << FailingTool.getShortName() << -Res;
409 else
410 Diag(clang::diag::err_drv_command_failed)
411 << FailingTool.getShortName() << Res;
Daniel Dunbar38bfda62009-07-01 20:03:04 +0000412 }
413
414 return Res;
415}
416
Daniel Dunbar446f6842009-03-12 18:24:49 +0000417void Driver::PrintOptions(const ArgList &Args) const {
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000418 unsigned i = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000419 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000420 it != ie; ++it, ++i) {
421 Arg *A = *it;
422 llvm::errs() << "Option " << i << " - "
423 << "Name: \"" << A->getOption().getName() << "\", "
424 << "Values: {";
425 for (unsigned j = 0; j < A->getNumValues(); ++j) {
426 if (j)
427 llvm::errs() << ", ";
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000428 llvm::errs() << '"' << A->getValue(Args, j) << '"';
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000429 }
430 llvm::errs() << "}\n";
Daniel Dunbard02cb1d2009-03-05 06:38:47 +0000431 }
Daniel Dunbar544ecd12009-03-02 19:59:07 +0000432}
Daniel Dunbar4dff6a42009-03-10 23:41:59 +0000433
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000434void Driver::PrintHelp(bool ShowHidden) const {
Daniel Dunbar3babf5d2010-02-25 03:31:53 +0000435 getOpts().PrintHelp(llvm::outs(), Name.c_str(), DriverTitle.c_str(),
436 ShowHidden);
Daniel Dunbar7c925282009-03-31 21:38:17 +0000437}
438
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000439void Driver::PrintVersion(const Compilation &C, raw_ostream &OS) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000440 // FIXME: The following handlers should use a callback mechanism, we don't
441 // know what the client would like to do.
Ted Kremenek4c0df3d2010-01-23 02:11:34 +0000442 OS << getClangFullVersion() << '\n';
Daniel Dunbarb10248802009-03-26 16:09:13 +0000443 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000444 OS << "Target: " << TC.getTripleString() << '\n';
Daniel Dunbar10978e42009-06-16 23:32:58 +0000445
446 // Print the threading model.
447 //
448 // FIXME: Implement correctly.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000449 OS << "Thread model: " << "posix" << '\n';
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000450}
451
Chris Lattner86ed5b02010-05-05 05:53:24 +0000452/// PrintDiagnosticCategories - Implement the --print-diagnostic-categories
453/// option.
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000454static void PrintDiagnosticCategories(raw_ostream &OS) {
Argyrios Kyrtzidis0e37afa2011-05-25 05:05:01 +0000455 // Skip the empty category.
456 for (unsigned i = 1, max = DiagnosticIDs::getNumberOfCategories();
457 i != max; ++i)
458 OS << i << ',' << DiagnosticIDs::getCategoryNameFromID(i) << '\n';
Chris Lattner86ed5b02010-05-05 05:53:24 +0000459}
460
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000461bool Driver::HandleImmediateArgs(const Compilation &C) {
Daniel Dunbar18974bd2010-06-11 22:00:19 +0000462 // The order these options are handled in gcc is all over the place, but we
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000463 // don't expect inconsistencies w.r.t. that to matter in practice.
Daniel Dunbar7c925282009-03-31 21:38:17 +0000464
Daniel Dunbar1b09e042010-09-17 02:47:28 +0000465 if (C.getArgs().hasArg(options::OPT_dumpmachine)) {
466 llvm::outs() << C.getDefaultToolChain().getTripleString() << '\n';
467 return false;
468 }
469
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000470 if (C.getArgs().hasArg(options::OPT_dumpversion)) {
Daniel Dunbare26e5002011-01-12 00:43:47 +0000471 // Since -dumpversion is only implemented for pedantic GCC compatibility, we
472 // return an answer which matches our definition of __VERSION__.
473 //
474 // If we want to return a more correct answer some day, then we should
475 // introduce a non-pedantically GCC compatible mode to Clang in which we
476 // provide sensible definitions for -dumpversion, __VERSION__, etc.
477 llvm::outs() << "4.2.1\n";
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000478 return false;
479 }
Daniel Dunbarfb3d7472010-06-14 21:23:12 +0000480
Chris Lattner86ed5b02010-05-05 05:53:24 +0000481 if (C.getArgs().hasArg(options::OPT__print_diagnostic_categories)) {
482 PrintDiagnosticCategories(llvm::outs());
483 return false;
484 }
Daniel Dunbara9bbcfa2009-04-04 05:17:38 +0000485
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000486 if (C.getArgs().hasArg(options::OPT__help) ||
Daniel Dunbara7b5e212009-04-15 16:34:29 +0000487 C.getArgs().hasArg(options::OPT__help_hidden)) {
488 PrintHelp(C.getArgs().hasArg(options::OPT__help_hidden));
Daniel Dunbar7c925282009-03-31 21:38:17 +0000489 return false;
490 }
491
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000492 if (C.getArgs().hasArg(options::OPT__version)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000493 // Follow gcc behavior and use stdout for --version and stderr for -v.
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000494 PrintVersion(C, llvm::outs());
Daniel Dunbarb0006ae2009-04-02 15:05:41 +0000495 return false;
496 }
497
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000498 if (C.getArgs().hasArg(options::OPT_v) ||
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000499 C.getArgs().hasArg(options::OPT__HASH_HASH_HASH)) {
Daniel Dunbar08e41d62009-07-21 20:06:58 +0000500 PrintVersion(C, llvm::errs());
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000501 SuppressMissingInputWarning = true;
502 }
503
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000504 const ToolChain &TC = C.getDefaultToolChain();
Daniel Dunbard972e222009-03-20 04:37:21 +0000505 if (C.getArgs().hasArg(options::OPT_print_search_dirs)) {
506 llvm::outs() << "programs: =";
507 for (ToolChain::path_list::const_iterator it = TC.getProgramPaths().begin(),
508 ie = TC.getProgramPaths().end(); it != ie; ++it) {
509 if (it != TC.getProgramPaths().begin())
510 llvm::outs() << ':';
511 llvm::outs() << *it;
512 }
513 llvm::outs() << "\n";
514 llvm::outs() << "libraries: =";
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000515
516 std::string sysroot;
517 if (Arg *A = C.getArgs().getLastArg(options::OPT__sysroot_EQ))
518 sysroot = A->getValue(C.getArgs());
519
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000520 for (ToolChain::path_list::const_iterator it = TC.getFilePaths().begin(),
Daniel Dunbard972e222009-03-20 04:37:21 +0000521 ie = TC.getFilePaths().end(); it != ie; ++it) {
522 if (it != TC.getFilePaths().begin())
523 llvm::outs() << ':';
Joerg Sonnenberger9c3e69b2011-07-16 10:50:05 +0000524 const char *path = it->c_str();
525 if (path[0] == '=')
526 llvm::outs() << sysroot << path + 1;
527 else
528 llvm::outs() << path;
Daniel Dunbard972e222009-03-20 04:37:21 +0000529 }
530 llvm::outs() << "\n";
Daniel Dunbar7c925282009-03-31 21:38:17 +0000531 return false;
Daniel Dunbard972e222009-03-20 04:37:21 +0000532 }
533
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000534 // FIXME: The following handlers should use a callback mechanism, we don't
535 // know what the client would like to do.
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000536 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_file_name_EQ)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000537 llvm::outs() << GetFilePath(A->getValue(C.getArgs()), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000538 return false;
539 }
540
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000541 if (Arg *A = C.getArgs().getLastArg(options::OPT_print_prog_name_EQ)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000542 llvm::outs() << GetProgramPath(A->getValue(C.getArgs()), TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000543 return false;
544 }
545
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000546 if (C.getArgs().hasArg(options::OPT_print_libgcc_file_name)) {
Daniel Dunbar1ce81532009-09-09 22:33:00 +0000547 llvm::outs() << GetFilePath("libgcc.a", TC) << "\n";
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000548 return false;
549 }
550
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000551 if (C.getArgs().hasArg(options::OPT_print_multi_lib)) {
552 // FIXME: We need tool chain support for this.
553 llvm::outs() << ".;\n";
554
555 switch (C.getDefaultToolChain().getTriple().getArch()) {
556 default:
557 break;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000558
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000559 case llvm::Triple::x86_64:
560 llvm::outs() << "x86_64;@m64" << "\n";
561 break;
562
563 case llvm::Triple::ppc64:
564 llvm::outs() << "ppc64;@m64" << "\n";
565 break;
566 }
567 return false;
568 }
569
570 // FIXME: What is the difference between print-multi-directory and
571 // print-multi-os-directory?
572 if (C.getArgs().hasArg(options::OPT_print_multi_directory) ||
573 C.getArgs().hasArg(options::OPT_print_multi_os_directory)) {
574 switch (C.getDefaultToolChain().getTriple().getArch()) {
575 default:
576 case llvm::Triple::x86:
577 case llvm::Triple::ppc:
578 llvm::outs() << "." << "\n";
579 break;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000580
Daniel Dunbar1b3ec3a2009-06-16 23:25:22 +0000581 case llvm::Triple::x86_64:
582 llvm::outs() << "x86_64" << "\n";
583 break;
584
585 case llvm::Triple::ppc64:
586 llvm::outs() << "ppc64" << "\n";
587 break;
588 }
589 return false;
590 }
591
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +0000592 return true;
593}
594
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000595static unsigned PrintActions1(const Compilation &C, Action *A,
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000596 std::map<Action*, unsigned> &Ids) {
597 if (Ids.count(A))
598 return Ids[A];
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000599
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000600 std::string str;
601 llvm::raw_string_ostream os(str);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000602
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000603 os << Action::getClassName(A->getKind()) << ", ";
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000604 if (InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000605 os << "\"" << IA->getInputArg().getValue(C.getArgs()) << "\"";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000606 } else if (BindArchAction *BIA = dyn_cast<BindArchAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000607 os << '"' << (BIA->getArchName() ? BIA->getArchName() :
Daniel Dunbareb843be2009-03-18 03:13:20 +0000608 C.getDefaultToolChain().getArchName()) << '"'
609 << ", {" << PrintActions1(C, *BIA->begin(), Ids) << "}";
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000610 } else {
611 os << "{";
612 for (Action::iterator it = A->begin(), ie = A->end(); it != ie;) {
Daniel Dunbareb843be2009-03-18 03:13:20 +0000613 os << PrintActions1(C, *it, Ids);
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000614 ++it;
615 if (it != ie)
616 os << ", ";
617 }
618 os << "}";
619 }
620
621 unsigned Id = Ids.size();
622 Ids[A] = Id;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000623 llvm::errs() << Id << ": " << os.str() << ", "
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000624 << types::getTypeName(A->getType()) << "\n";
625
626 return Id;
627}
628
Daniel Dunbareb843be2009-03-18 03:13:20 +0000629void Driver::PrintActions(const Compilation &C) const {
Daniel Dunbaraaf1ea62009-03-13 12:19:02 +0000630 std::map<Action*, unsigned> Ids;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000631 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbareb843be2009-03-18 03:13:20 +0000632 ie = C.getActions().end(); it != ie; ++it)
633 PrintActions1(C, *it, Ids);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000634}
635
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +0000636/// \brief Check whether the given input tree contains any compilation or
637/// assembly actions.
638static bool ContainsCompileOrAssembleAction(const Action *A) {
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000639 if (isa<CompileJobAction>(A) || isa<AssembleJobAction>(A))
640 return true;
641
642 for (Action::const_iterator it = A->begin(), ie = A->end(); it != ie; ++it)
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +0000643 if (ContainsCompileOrAssembleAction(*it))
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000644 return true;
645
646 return false;
647}
648
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000649void Driver::BuildUniversalActions(const ToolChain &TC,
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000650 const DerivedArgList &Args,
Daniel Dunbarf0eddb82009-03-18 02:55:38 +0000651 ActionList &Actions) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000652 llvm::PrettyStackTraceString CrashInfo("Building universal build actions");
653 // Collect the list of architectures. Duplicates are allowed, but should only
654 // be handled once (in the order seen).
Daniel Dunbare5dc4822009-03-13 20:33:35 +0000655 llvm::StringSet<> ArchNames;
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000656 SmallVector<const char *, 4> Archs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000657 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbarf479c122009-03-12 18:40:18 +0000658 it != ie; ++it) {
659 Arg *A = *it;
660
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000661 if (A->getOption().matches(options::OPT_arch)) {
Daniel Dunbar9c3f7c42009-09-08 23:37:30 +0000662 // Validate the option here; we don't save the type here because its
663 // particular spelling may participate in other driver choices.
664 llvm::Triple::ArchType Arch =
665 llvm::Triple::getArchTypeForDarwinArchName(A->getValue(Args));
666 if (Arch == llvm::Triple::UnknownArch) {
667 Diag(clang::diag::err_drv_invalid_arch_name)
668 << A->getAsString(Args);
669 continue;
670 }
671
Daniel Dunbar2da02722009-03-19 07:55:12 +0000672 A->claim();
Daniel Dunbar7b574042009-09-08 23:37:02 +0000673 if (ArchNames.insert(A->getValue(Args)))
674 Archs.push_back(A->getValue(Args));
Daniel Dunbarf479c122009-03-12 18:40:18 +0000675 }
676 }
677
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000678 // When there is no explicit arch for this platform, make sure we still bind
679 // the architecture (to the default) so that -Xarch_ is handled correctly.
Daniel Dunbareb843be2009-03-18 03:13:20 +0000680 if (!Archs.size())
681 Archs.push_back(0);
Daniel Dunbarf479c122009-03-12 18:40:18 +0000682
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000683 // FIXME: We killed off some others but these aren't yet detected in a
684 // functional manner. If we added information to jobs about which "auxiliary"
685 // files they wrote then we could detect the conflict these cause downstream.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000686 if (Archs.size() > 1) {
687 // No recovery needed, the point of this is just to prevent
688 // overwriting the same files.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000689 if (const Arg *A = Args.getLastArg(options::OPT_save_temps))
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000690 Diag(clang::diag::err_drv_invalid_opt_with_multiple_archs)
Daniel Dunbar0e759942009-03-20 06:14:23 +0000691 << A->getAsString(Args);
Daniel Dunbarf479c122009-03-12 18:40:18 +0000692 }
693
694 ActionList SingleActions;
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000695 BuildActions(TC, Args, SingleActions);
Daniel Dunbarf479c122009-03-12 18:40:18 +0000696
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000697 // Add in arch bindings for every top level action, as well as lipo and
698 // dsymutil steps if needed.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000699 for (unsigned i = 0, e = SingleActions.size(); i != e; ++i) {
700 Action *Act = SingleActions[i];
701
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000702 // Make sure we can lipo this kind of output. If not (and it is an actual
703 // output) then we disallow, since we can't create an output file with the
704 // right name without overwriting it. We could remove this oddity by just
705 // changing the output names to include the arch, which would also fix
Daniel Dunbarf479c122009-03-12 18:40:18 +0000706 // -save-temps. Compatibility wins for now.
707
Daniel Dunbare2ca3bd2009-03-13 17:46:02 +0000708 if (Archs.size() > 1 && !types::canLipoType(Act->getType()))
Daniel Dunbarf479c122009-03-12 18:40:18 +0000709 Diag(clang::diag::err_drv_invalid_output_with_multiple_archs)
710 << types::getTypeName(Act->getType());
711
712 ActionList Inputs;
Daniel Dunbar66187b32010-03-11 18:04:58 +0000713 for (unsigned i = 0, e = Archs.size(); i != e; ++i) {
Daniel Dunbare5dc4822009-03-13 20:33:35 +0000714 Inputs.push_back(new BindArchAction(Act, Archs[i]));
Daniel Dunbar66187b32010-03-11 18:04:58 +0000715 if (i != 0)
716 Inputs.back()->setOwnsInputs(false);
717 }
Daniel Dunbarf479c122009-03-12 18:40:18 +0000718
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000719 // Lipo if necessary, we do it this way because we need to set the arch flag
720 // so that -Xarch_ gets overwritten.
Daniel Dunbarf479c122009-03-12 18:40:18 +0000721 if (Inputs.size() == 1 || Act->getType() == types::TY_Nothing)
722 Actions.append(Inputs.begin(), Inputs.end());
723 else
724 Actions.push_back(new LipoJobAction(Inputs, Act->getType()));
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000725
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000726 // Add a 'dsymutil' step if necessary, when debug info is enabled and we
727 // have a compile input. We need to run 'dsymutil' ourselves in such cases
728 // because the debug info will refer to a temporary object file which is
729 // will be removed at the end of the compilation process.
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000730 if (Act->getType() == types::TY_Image) {
731 Arg *A = Args.getLastArg(options::OPT_g_Group);
732 if (A && !A->getOption().matches(options::OPT_g0) &&
Daniel Dunbar00d3d8e2010-06-29 16:38:33 +0000733 !A->getOption().matches(options::OPT_gstabs) &&
Joerg Sonnenberger5fe4a7d2011-05-06 14:05:11 +0000734 ContainsCompileOrAssembleAction(Actions.back())) {
Daniel Dunbar6beaf512010-06-04 18:28:41 +0000735 ActionList Inputs;
736 Inputs.push_back(Actions.back());
737 Actions.pop_back();
738
739 Actions.push_back(new DsymutilJobAction(Inputs, types::TY_dSYM));
740 }
741 }
Daniel Dunbarf479c122009-03-12 18:40:18 +0000742 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000743}
744
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000745void Driver::BuildActions(const ToolChain &TC, const DerivedArgList &Args,
Daniel Dunbara36c2b32010-08-02 05:43:51 +0000746 ActionList &Actions) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000747 llvm::PrettyStackTraceString CrashInfo("Building compilation actions");
Daniel Dunbarbfeec742009-03-12 23:55:14 +0000748 // Start by constructing the list of inputs and their types.
749
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000750 // Track the current user specified (-x) input. We also explicitly track the
751 // argument used to set the type; we only want to claim the type when we
752 // actually use it, so we warn about unused -x arguments.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +0000753 types::ID InputType = types::TY_Nothing;
754 Arg *InputTypeArg = 0;
755
Chris Lattner0e62c1c2011-07-23 10:55:15 +0000756 SmallVector<std::pair<types::ID, const Arg*>, 16> Inputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000757 for (ArgList::const_iterator it = Args.begin(), ie = Args.end();
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000758 it != ie; ++it) {
759 Arg *A = *it;
760
761 if (isa<InputOption>(A->getOption())) {
762 const char *Value = A->getValue(Args);
763 types::ID Ty = types::TY_INVALID;
764
765 // Infer the input type if necessary.
Daniel Dunbarc5a5ac52009-03-13 17:57:10 +0000766 if (InputType == types::TY_Nothing) {
767 // If there was an explicit arg for this, claim it.
768 if (InputTypeArg)
769 InputTypeArg->claim();
770
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000771 // stdin must be handled specially.
772 if (memcmp(Value, "-", 2) == 0) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000773 // If running with -E, treat as a C input (this changes the builtin
774 // macros, for example). This may be overridden by -ObjC below.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000775 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000776 // Otherwise emit an error but still use a valid type to avoid
777 // spurious errors (e.g., no inputs).
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +0000778 if (!Args.hasArgNoClaim(options::OPT_E) && !CCCIsCPP)
Daniel Dunbar5cd1e412009-03-12 09:13:48 +0000779 Diag(clang::diag::err_drv_unknown_stdin_type);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000780 Ty = types::TY_C;
781 } else {
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +0000782 // Otherwise lookup by extension.
783 // Fallback is C if invoked as C preprocessor or Object otherwise.
784 // We use a host hook here because Darwin at least has its own
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000785 // idea of what .s is.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000786 if (const char *Ext = strrchr(Value, '.'))
Daniel Dunbarcc7df6c2010-08-02 05:43:56 +0000787 Ty = TC.LookupTypeForExtension(Ext + 1);
Daniel Dunbarea9f0322009-03-20 23:39:23 +0000788
Joerg Sonnenbergerbdbdf702011-03-16 22:45:02 +0000789 if (Ty == types::TY_INVALID) {
790 if (CCCIsCPP)
791 Ty = types::TY_C;
792 else
793 Ty = types::TY_Object;
794 }
Daniel Dunbar0ac94452010-02-17 20:32:58 +0000795
796 // If the driver is invoked as C++ compiler (like clang++ or c++) it
797 // should autodetect some input files as C++ for g++ compatibility.
798 if (CCCIsCXX) {
799 types::ID OldTy = Ty;
800 Ty = types::lookupCXXTypeForCType(Ty);
801
802 if (Ty != OldTy)
803 Diag(clang::diag::warn_drv_treating_input_as_cxx)
804 << getTypeName(OldTy) << getTypeName(Ty);
805 }
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000806 }
807
Daniel Dunbar82b22102009-05-18 21:47:54 +0000808 // -ObjC and -ObjC++ override the default language, but only for "source
809 // files". We just treat everything that isn't a linker input as a
810 // source file.
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000811 //
Daniel Dunbar82b22102009-05-18 21:47:54 +0000812 // FIXME: Clean this up if we move the phase sequence into the type.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000813 if (Ty != types::TY_Object) {
814 if (Args.hasArg(options::OPT_ObjC))
815 Ty = types::TY_ObjC;
816 else if (Args.hasArg(options::OPT_ObjCXX))
817 Ty = types::TY_ObjCXX;
818 }
819 } else {
820 assert(InputTypeArg && "InputType set w/o InputTypeArg");
821 InputTypeArg->claim();
822 Ty = InputType;
823 }
824
Daniel Dunbarfcf2d422010-01-25 00:44:02 +0000825 // Check that the file exists, if enabled.
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000826 if (CheckInputsExist && memcmp(Value, "-", 2) != 0) {
Michael J. Spencerf28df4c2010-12-17 21:22:22 +0000827 llvm::SmallString<64> Path(Value);
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000828 if (Arg *WorkDir = Args.getLastArg(options::OPT_working_directory))
Michael J. Spencerf28df4c2010-12-17 21:22:22 +0000829 if (llvm::sys::path::is_absolute(Path.str())) {
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000830 Path = WorkDir->getValue(Args);
Michael J. Spencerf28df4c2010-12-17 21:22:22 +0000831 llvm::sys::path::append(Path, Value);
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000832 }
833
Michael J. Spencerf28df4c2010-12-17 21:22:22 +0000834 bool exists = false;
835 if (/*error_code ec =*/llvm::sys::fs::exists(Value, exists) || !exists)
Argyrios Kyrtzidis71731d62010-11-03 22:45:23 +0000836 Diag(clang::diag::err_drv_no_such_file) << Path.str();
837 else
838 Inputs.push_back(std::make_pair(Ty, A));
839 } else
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000840 Inputs.push_back(std::make_pair(Ty, A));
841
842 } else if (A->getOption().isLinkerInput()) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000843 // Just treat as object type, we could make a special type for this if
844 // necessary.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000845 Inputs.push_back(std::make_pair(types::TY_Object, A));
846
Daniel Dunbar0bfb21e2009-11-19 03:26:40 +0000847 } else if (A->getOption().matches(options::OPT_x)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000848 InputTypeArg = A;
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000849 InputType = types::lookupTypeForTypeSpecifier(A->getValue(Args));
850
851 // Follow gcc behavior and treat as linker input for invalid -x
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000852 // options. Its not clear why we shouldn't just revert to unknown; but
Michael J. Spencer1a4fe8c2010-12-17 21:22:33 +0000853 // this isn't very important, we might as well be bug compatible.
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000854 if (!InputType) {
Daniel Dunbar5cd1e412009-03-12 09:13:48 +0000855 Diag(clang::diag::err_drv_unknown_language) << A->getValue(Args);
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000856 InputType = types::TY_Object;
857 }
858 }
859 }
860
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +0000861 if (CCCIsCPP && Inputs.empty()) {
862 // If called as standalone preprocessor, stdin is processed
863 // if no other input is present.
Joerg Sonnenbergerf4961642011-03-07 01:15:29 +0000864 unsigned Index = Args.getBaseArgs().MakeIndex("-");
Joerg Sonnenbergerb86f5f42011-03-06 23:31:01 +0000865 Arg *A = Opts->ParseOneArg(Args, Index);
866 A->claim();
867 Inputs.push_back(std::make_pair(types::TY_C, A));
868 }
869
Daniel Dunbar34c41872009-03-13 00:17:48 +0000870 if (!SuppressMissingInputWarning && Inputs.empty()) {
Daniel Dunbarbfeec742009-03-12 23:55:14 +0000871 Diag(clang::diag::err_drv_no_input_files);
872 return;
873 }
874
Chad Rosier7742b5d2011-07-27 23:36:45 +0000875 Arg *FinalPhaseArg;
876 phases::ID FinalPhase = getFinalPhase(Args, &FinalPhaseArg);
Daniel Dunbarbfeec742009-03-12 23:55:14 +0000877
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000878 // Reject -Z* at the top level, these options should never have been exposed
879 // by gcc.
Daniel Dunbardd765242009-03-26 16:12:09 +0000880 if (Arg *A = Args.getLastArg(options::OPT_Z_Joined))
Daniel Dunbar0e759942009-03-20 06:14:23 +0000881 Diag(clang::diag::err_drv_use_of_Z_option) << A->getAsString(Args);
Daniel Dunbarbfeec742009-03-12 23:55:14 +0000882
Daniel Dunbar65229332009-03-13 11:38:42 +0000883 // Construct the actions to perform.
884 ActionList LinkerInputs;
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000885 for (unsigned i = 0, e = Inputs.size(); i != e; ++i) {
Daniel Dunbar65229332009-03-13 11:38:42 +0000886 types::ID InputType = Inputs[i].first;
887 const Arg *InputArg = Inputs[i].second;
888
889 unsigned NumSteps = types::getNumCompilationPhases(InputType);
890 assert(NumSteps && "Invalid number of steps!");
891
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000892 // If the first step comes after the final phase we are doing as part of
893 // this compilation, warn the user about it.
Daniel Dunbar65229332009-03-13 11:38:42 +0000894 phases::ID InitialPhase = types::getCompilationPhase(InputType, 0);
895 if (InitialPhase > FinalPhase) {
Daniel Dunbaradc5c7c2009-03-19 07:57:08 +0000896 // Claim here to avoid the more general unused warning.
897 InputArg->claim();
Daniel Dunbar07806ca2009-09-17 04:13:26 +0000898
Daniel Dunbar2db3e732011-04-20 15:44:48 +0000899 // Suppress all unused style warnings with -Qunused-arguments
900 if (Args.hasArg(options::OPT_Qunused_arguments))
901 continue;
902
Daniel Dunbar07806ca2009-09-17 04:13:26 +0000903 // Special case '-E' warning on a previously preprocessed file to make
904 // more sense.
905 if (InitialPhase == phases::Compile && FinalPhase == phases::Preprocess &&
906 getPreprocessedType(InputType) == types::TY_INVALID)
907 Diag(clang::diag::warn_drv_preprocessed_input_file_unused)
908 << InputArg->getAsString(Args)
909 << FinalPhaseArg->getOption().getName();
910 else
911 Diag(clang::diag::warn_drv_input_file_unused)
912 << InputArg->getAsString(Args)
913 << getPhaseName(InitialPhase)
914 << FinalPhaseArg->getOption().getName();
Daniel Dunbar65229332009-03-13 11:38:42 +0000915 continue;
916 }
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000917
Daniel Dunbar65229332009-03-13 11:38:42 +0000918 // Build the pipeline for this file.
Ted Kremenekbb1110a2010-01-19 01:29:05 +0000919 llvm::OwningPtr<Action> Current(new InputAction(*InputArg, InputType));
Daniel Dunbar65229332009-03-13 11:38:42 +0000920 for (unsigned i = 0; i != NumSteps; ++i) {
921 phases::ID Phase = types::getCompilationPhase(InputType, i);
922
923 // We are done if this step is past what the user requested.
924 if (Phase > FinalPhase)
925 break;
926
927 // Queue linker inputs.
928 if (Phase == phases::Link) {
929 assert(i + 1 == NumSteps && "linking must be final compilation step.");
Ted Kremenekbb1110a2010-01-19 01:29:05 +0000930 LinkerInputs.push_back(Current.take());
Daniel Dunbar65229332009-03-13 11:38:42 +0000931 break;
932 }
933
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000934 // Some types skip the assembler phase (e.g., llvm-bc), but we can't
935 // encode this in the steps because the intermediate type depends on
936 // arguments. Just special case here.
Daniel Dunbar13864952009-03-24 20:17:30 +0000937 if (Phase == phases::Assemble && Current->getType() != types::TY_PP_Asm)
938 continue;
939
Daniel Dunbar65229332009-03-13 11:38:42 +0000940 // Otherwise construct the appropriate action.
Ted Kremenekbb1110a2010-01-19 01:29:05 +0000941 Current.reset(ConstructPhaseAction(Args, Phase, Current.take()));
Daniel Dunbar65229332009-03-13 11:38:42 +0000942 if (Current->getType() == types::TY_Nothing)
943 break;
944 }
945
946 // If we ended with something, add to the output list.
947 if (Current)
Ted Kremenekbb1110a2010-01-19 01:29:05 +0000948 Actions.push_back(Current.take());
Daniel Dunbar1688f1a2009-03-12 07:58:46 +0000949 }
Daniel Dunbar65229332009-03-13 11:38:42 +0000950
951 // Add a link action if necessary.
952 if (!LinkerInputs.empty())
953 Actions.push_back(new LinkJobAction(LinkerInputs, types::TY_Image));
Daniel Dunbarc7a67b72009-12-22 23:19:32 +0000954
955 // If we are linking, claim any options which are obviously only used for
956 // compilation.
957 if (FinalPhase == phases::Link)
958 Args.ClaimAllArgs(options::OPT_CompileOnly_Group);
Daniel Dunbar65229332009-03-13 11:38:42 +0000959}
960
961Action *Driver::ConstructPhaseAction(const ArgList &Args, phases::ID Phase,
962 Action *Input) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +0000963 llvm::PrettyStackTraceString CrashInfo("Constructing phase actions");
Daniel Dunbar65229332009-03-13 11:38:42 +0000964 // Build the appropriate action.
965 switch (Phase) {
966 case phases::Link: assert(0 && "link action invalid here.");
967 case phases::Preprocess: {
Daniel Dunbard67a3222009-03-30 06:36:42 +0000968 types::ID OutputTy;
969 // -{M, MM} alter the output type.
Daniel Dunbar86aed7d2010-12-08 21:33:40 +0000970 if (Args.hasArg(options::OPT_M, options::OPT_MM)) {
Daniel Dunbard67a3222009-03-30 06:36:42 +0000971 OutputTy = types::TY_Dependencies;
972 } else {
973 OutputTy = types::getPreprocessedType(Input->getType());
974 assert(OutputTy != types::TY_INVALID &&
975 "Cannot preprocess this input type!");
976 }
Daniel Dunbar65229332009-03-13 11:38:42 +0000977 return new PreprocessJobAction(Input, OutputTy);
978 }
979 case phases::Precompile:
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000980 return new PrecompileJobAction(Input, types::TY_PCH);
Daniel Dunbar65229332009-03-13 11:38:42 +0000981 case phases::Compile: {
982 if (Args.hasArg(options::OPT_fsyntax_only)) {
983 return new CompileJobAction(Input, types::TY_Nothing);
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +0000984 } else if (Args.hasArg(options::OPT_rewrite_objc)) {
985 return new CompileJobAction(Input, types::TY_RewrittenObjC);
Daniel Dunbar5e051f92009-05-06 02:12:32 +0000986 } else if (Args.hasArg(options::OPT__analyze, options::OPT__analyze_auto)) {
Daniel Dunbar65229332009-03-13 11:38:42 +0000987 return new AnalyzeJobAction(Input, types::TY_Plist);
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +0000988 } else if (Args.hasArg(options::OPT_emit_ast)) {
989 return new CompileJobAction(Input, types::TY_AST);
Daniel Dunbar8f1fe5b2011-06-21 20:55:08 +0000990 } else if (IsUsingLTO(Args)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +0000991 types::ID Output =
Daniel Dunbar24e52992010-06-07 23:28:45 +0000992 Args.hasArg(options::OPT_S) ? types::TY_LTO_IR : types::TY_LTO_BC;
Daniel Dunbar65229332009-03-13 11:38:42 +0000993 return new CompileJobAction(Input, Output);
994 } else {
995 return new CompileJobAction(Input, types::TY_PP_Asm);
996 }
997 }
998 case phases::Assemble:
999 return new AssembleJobAction(Input, types::TY_Object);
1000 }
1001
1002 assert(0 && "invalid phase in ConstructPhaseAction");
1003 return 0;
Daniel Dunbar1688f1a2009-03-12 07:58:46 +00001004}
1005
Daniel Dunbar8f1fe5b2011-06-21 20:55:08 +00001006bool Driver::IsUsingLTO(const ArgList &Args) const {
1007 // Check for -emit-llvm or -flto.
1008 if (Args.hasArg(options::OPT_emit_llvm) ||
1009 Args.hasFlag(options::OPT_flto, options::OPT_fno_lto, false))
1010 return true;
1011
1012 // Check for -O4.
1013 if (const Arg *A = Args.getLastArg(options::OPT_O_Group))
1014 return A->getOption().matches(options::OPT_O4);
1015
1016 return false;
1017}
1018
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001019void Driver::BuildJobs(Compilation &C) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001020 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001021
1022 Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o);
1023
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001024 // It is an error to provide a -o option if we are making multiple output
1025 // files.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001026 if (FinalOutput) {
1027 unsigned NumOutputs = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001028 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001029 ie = C.getActions().end(); it != ie; ++it)
Daniel Dunbare75d8342009-03-16 06:56:51 +00001030 if ((*it)->getType() != types::TY_Nothing)
1031 ++NumOutputs;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001032
Daniel Dunbare75d8342009-03-16 06:56:51 +00001033 if (NumOutputs > 1) {
1034 Diag(clang::diag::err_drv_output_argument_with_multiple_files);
1035 FinalOutput = 0;
1036 }
1037 }
1038
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001039 for (ActionList::const_iterator it = C.getActions().begin(),
Daniel Dunbarf0eddb82009-03-18 02:55:38 +00001040 ie = C.getActions().end(); it != ie; ++it) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001041 Action *A = *it;
1042
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001043 // If we are linking an image for multiple archs then the linker wants
1044 // -arch_multiple and -final_output <final image name>. Unfortunately, this
1045 // doesn't fit in cleanly because we have to pass this information down.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001046 //
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001047 // FIXME: This is a hack; find a cleaner way to integrate this into the
1048 // process.
Daniel Dunbare75d8342009-03-16 06:56:51 +00001049 const char *LinkingOutput = 0;
Daniel Dunbardd765242009-03-26 16:12:09 +00001050 if (isa<LipoJobAction>(A)) {
Daniel Dunbare75d8342009-03-16 06:56:51 +00001051 if (FinalOutput)
1052 LinkingOutput = FinalOutput->getValue(C.getArgs());
1053 else
1054 LinkingOutput = DefaultImageName.c_str();
1055 }
1056
1057 InputInfo II;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001058 BuildJobsForAction(C, A, &C.getDefaultToolChain(),
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001059 /*BoundArch*/0,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001060 /*AtTopLevel*/ true,
1061 /*LinkingOutput*/ LinkingOutput,
1062 II);
1063 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001064
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001065 // If the user passed -Qunused-arguments or there were errors, don't warn
1066 // about any unused arguments.
Argyrios Kyrtzidis31448a42010-11-18 21:47:07 +00001067 if (Diags.hasErrorOccurred() ||
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001068 C.getArgs().hasArg(options::OPT_Qunused_arguments))
Daniel Dunbard175d972009-03-18 18:03:46 +00001069 return;
1070
Daniel Dunbar58399ae2009-03-29 22:24:54 +00001071 // Claim -### here.
1072 (void) C.getArgs().hasArg(options::OPT__HASH_HASH_HASH);
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001073
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001074 for (ArgList::const_iterator it = C.getArgs().begin(), ie = C.getArgs().end();
1075 it != ie; ++it) {
1076 Arg *A = *it;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001077
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001078 // FIXME: It would be nice to be able to send the argument to the
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001079 // Diagnostic, so that extra values, position, and so on could be printed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001080 if (!A->isClaimed()) {
Daniel Dunbara3cfbe32009-04-07 19:04:18 +00001081 if (A->getOption().hasNoArgumentUnused())
1082 continue;
1083
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001084 // Suppress the warning automatically if this is just a flag, and it is an
1085 // instance of an argument we already claimed.
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001086 const Option &Opt = A->getOption();
1087 if (isa<FlagOption>(Opt)) {
1088 bool DuplicateClaimed = false;
1089
Daniel Dunbar44b36ee2009-11-25 11:53:23 +00001090 for (arg_iterator it = C.getArgs().filtered_begin(&Opt),
1091 ie = C.getArgs().filtered_end(); it != ie; ++it) {
1092 if ((*it)->isClaimed()) {
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001093 DuplicateClaimed = true;
1094 break;
1095 }
1096 }
1097
1098 if (DuplicateClaimed)
1099 continue;
1100 }
1101
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001102 Diag(clang::diag::warn_drv_unused_argument)
Daniel Dunbar0e759942009-03-20 06:14:23 +00001103 << A->getAsString(C.getArgs());
Daniel Dunbar90dd6f42009-04-04 00:52:26 +00001104 }
Daniel Dunbar3ce436d2009-03-16 06:42:30 +00001105 }
Daniel Dunbar95e6b192009-03-13 22:12:33 +00001106}
1107
Daniel Dunbarc4343942010-02-03 03:07:56 +00001108static const Tool &SelectToolForJob(Compilation &C, const ToolChain *TC,
1109 const JobAction *JA,
1110 const ActionList *&Inputs) {
1111 const Tool *ToolForJob = 0;
1112
1113 // See if we should look for a compiler with an integrated assembler. We match
1114 // bottom up, so what we are actually looking for is an assembler job with a
1115 // compiler input.
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00001116
1117 // FIXME: This doesn't belong here, but ideally we will support static soon
1118 // anyway.
1119 bool HasStatic = (C.getArgs().hasArg(options::OPT_mkernel) ||
1120 C.getArgs().hasArg(options::OPT_static) ||
1121 C.getArgs().hasArg(options::OPT_fapple_kext));
Rafael Espindola6b314b32011-03-18 15:50:12 +00001122 bool IsDarwin = TC->getTriple().getOS() == llvm::Triple::Darwin;
1123 bool IsIADefault = TC->IsIntegratedAssemblerDefault() &&
1124 !(HasStatic && IsDarwin);
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00001125 if (C.getArgs().hasFlag(options::OPT_integrated_as,
Daniel Dunbarc4343942010-02-03 03:07:56 +00001126 options::OPT_no_integrated_as,
Daniel Dunbarf9ff3502010-05-14 02:03:00 +00001127 IsIADefault) &&
Daniel Dunbarc4343942010-02-03 03:07:56 +00001128 !C.getArgs().hasArg(options::OPT_save_temps) &&
1129 isa<AssembleJobAction>(JA) &&
1130 Inputs->size() == 1 && isa<CompileJobAction>(*Inputs->begin())) {
Daniel Dunbar1e1c3ca2011-03-18 20:14:00 +00001131 const Tool &Compiler = TC->SelectTool(
1132 C, cast<JobAction>(**Inputs->begin()), (*Inputs)[0]->getInputs());
Daniel Dunbarc4343942010-02-03 03:07:56 +00001133 if (Compiler.hasIntegratedAssembler()) {
1134 Inputs = &(*Inputs)[0]->getInputs();
1135 ToolForJob = &Compiler;
1136 }
1137 }
1138
1139 // Otherwise use the tool for the current job.
1140 if (!ToolForJob)
Daniel Dunbar1e1c3ca2011-03-18 20:14:00 +00001141 ToolForJob = &TC->SelectTool(C, *JA, *Inputs);
Daniel Dunbarc4343942010-02-03 03:07:56 +00001142
1143 // See if we should use an integrated preprocessor. We do so when we have
1144 // exactly one input, since this is the only use case we care about
1145 // (irrelevant since we don't support combine yet).
1146 if (Inputs->size() == 1 && isa<PreprocessJobAction>(*Inputs->begin()) &&
1147 !C.getArgs().hasArg(options::OPT_no_integrated_cpp) &&
1148 !C.getArgs().hasArg(options::OPT_traditional_cpp) &&
1149 !C.getArgs().hasArg(options::OPT_save_temps) &&
1150 ToolForJob->hasIntegratedCPP())
1151 Inputs = &(*Inputs)[0]->getInputs();
1152
1153 return *ToolForJob;
1154}
1155
Daniel Dunbare75d8342009-03-16 06:56:51 +00001156void Driver::BuildJobsForAction(Compilation &C,
1157 const Action *A,
1158 const ToolChain *TC,
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001159 const char *BoundArch,
Daniel Dunbare75d8342009-03-16 06:56:51 +00001160 bool AtTopLevel,
1161 const char *LinkingOutput,
1162 InputInfo &Result) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001163 llvm::PrettyStackTraceString CrashInfo("Building compilation jobs");
Daniel Dunbarc4acf9d2009-03-18 23:18:19 +00001164
Daniel Dunbare75d8342009-03-16 06:56:51 +00001165 if (const InputAction *IA = dyn_cast<InputAction>(A)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001166 // FIXME: It would be nice to not claim this here; maybe the old scheme of
1167 // just using Args was better?
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001168 const Arg &Input = IA->getInputArg();
1169 Input.claim();
Daniel Dunbar35cbfeb2010-06-09 22:31:08 +00001170 if (Input.getOption().matches(options::OPT_INPUT)) {
Daniel Dunbar5cdf3e02009-03-19 07:29:38 +00001171 const char *Name = Input.getValue(C.getArgs());
1172 Result = InputInfo(Name, A->getType(), Name);
1173 } else
1174 Result = InputInfo(&Input, A->getType(), "");
Daniel Dunbare75d8342009-03-16 06:56:51 +00001175 return;
1176 }
1177
1178 if (const BindArchAction *BAA = dyn_cast<BindArchAction>(A)) {
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00001179 const ToolChain *TC = &C.getDefaultToolChain();
1180
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001181 std::string Arch;
Daniel Dunbar1ef3f2a2009-09-08 23:37:19 +00001182 if (BAA->getArchName())
1183 TC = Host->CreateToolChain(C.getArgs(), BAA->getArchName());
1184
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001185 BuildJobsForAction(C, *BAA->begin(), TC, BAA->getArchName(),
Daniel Dunbarc12a4122010-08-02 02:38:12 +00001186 AtTopLevel, LinkingOutput, Result);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001187 return;
1188 }
1189
Daniel Dunbare75d8342009-03-16 06:56:51 +00001190 const ActionList *Inputs = &A->getInputs();
Daniel Dunbarc4343942010-02-03 03:07:56 +00001191
1192 const JobAction *JA = cast<JobAction>(A);
1193 const Tool &T = SelectToolForJob(C, TC, JA, Inputs);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001194
1195 // Only use pipes when there is exactly one input.
Daniel Dunbar1a093d22009-03-18 06:00:36 +00001196 InputInfoList InputInfos;
Daniel Dunbare75d8342009-03-16 06:56:51 +00001197 for (ActionList::const_iterator it = Inputs->begin(), ie = Inputs->end();
1198 it != ie; ++it) {
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001199 // Treat dsymutil sub-jobs as being at the top-level too, they shouldn't get
1200 // temporary output names.
1201 //
1202 // FIXME: Clean this up.
1203 bool SubJobAtTopLevel = false;
1204 if (AtTopLevel && isa<DsymutilJobAction>(A))
1205 SubJobAtTopLevel = true;
1206
Daniel Dunbare75d8342009-03-16 06:56:51 +00001207 InputInfo II;
Daniel Dunbarc12a4122010-08-02 02:38:12 +00001208 BuildJobsForAction(C, *it, TC, BoundArch,
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001209 SubJobAtTopLevel, LinkingOutput, II);
Daniel Dunbare75d8342009-03-16 06:56:51 +00001210 InputInfos.push_back(II);
1211 }
1212
Daniel Dunbare75d8342009-03-16 06:56:51 +00001213 // Always use the first input as the base input.
1214 const char *BaseInput = InputInfos[0].getBaseInput();
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001215
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001216 // ... except dsymutil actions, which use their actual input as the base
1217 // input.
1218 if (JA->getType() == types::TY_dSYM)
1219 BaseInput = InputInfos[0].getFilename();
1220
Daniel Dunbard00272f2010-08-02 02:38:15 +00001221 // Determine the place to write output to, if any.
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001222 if (JA->getType() == types::TY_Nothing) {
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001223 Result = InputInfo(A->getType(), BaseInput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001224 } else {
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001225 Result = InputInfo(GetNamedOutputPath(C, *JA, BaseInput, AtTopLevel),
1226 A->getType(), BaseInput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001227 }
1228
Chad Rosier19886422011-07-20 21:16:17 +00001229 if (CCCPrintBindings) {
Daniel Dunbard67a3222009-03-30 06:36:42 +00001230 llvm::errs() << "# \"" << T.getToolChain().getTripleString() << '"'
1231 << " - \"" << T.getName() << "\", inputs: [";
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001232 for (unsigned i = 0, e = InputInfos.size(); i != e; ++i) {
1233 llvm::errs() << InputInfos[i].getAsString();
1234 if (i + 1 != e)
1235 llvm::errs() << ", ";
1236 }
1237 llvm::errs() << "], output: " << Result.getAsString() << "\n";
1238 } else {
Daniel Dunbar7fbaf532010-08-02 02:38:28 +00001239 T.ConstructJob(C, *JA, Result, InputInfos,
Daniel Dunbarb5d86bb2009-09-09 18:36:01 +00001240 C.getArgsForToolChain(TC, BoundArch), LinkingOutput);
Daniel Dunbarb39cc522009-03-17 22:47:06 +00001241 }
Daniel Dunbare75d8342009-03-16 06:56:51 +00001242}
1243
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001244const char *Driver::GetNamedOutputPath(Compilation &C,
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001245 const JobAction &JA,
1246 const char *BaseInput,
1247 bool AtTopLevel) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001248 llvm::PrettyStackTraceString CrashInfo("Computing output path");
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001249 // Output to a user requested destination?
Daniel Dunbar6beaf512010-06-04 18:28:41 +00001250 if (AtTopLevel && !isa<DsymutilJobAction>(JA)) {
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001251 if (Arg *FinalOutput = C.getArgs().getLastArg(options::OPT_o))
1252 return C.addResultFile(FinalOutput->getValue(C.getArgs()));
1253 }
1254
Nick Lewycky6e1ce292010-09-24 00:46:53 +00001255 // Default to writing to stdout?
Chad Rosier19886422011-07-20 21:16:17 +00001256 if (AtTopLevel && isa<PreprocessJobAction>(JA))
Nick Lewycky6e1ce292010-09-24 00:46:53 +00001257 return "-";
1258
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001259 // Output to a temporary file?
Chad Rosier19886422011-07-20 21:16:17 +00001260 if (!AtTopLevel && !C.getArgs().hasArg(options::OPT_save_temps)) {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001261 std::string TmpName =
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001262 GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
1263 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001264 }
1265
Michael J. Spencere1696752010-12-18 00:19:12 +00001266 llvm::SmallString<128> BasePath(BaseInput);
Chris Lattner0e62c1c2011-07-23 10:55:15 +00001267 StringRef BaseName;
Daniel Dunbar67fea712011-03-25 18:16:51 +00001268
1269 // Dsymutil actions should use the full path.
1270 if (isa<DsymutilJobAction>(JA))
1271 BaseName = BasePath;
1272 else
1273 BaseName = llvm::sys::path::filename(BasePath);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001274
1275 // Determine what the derived output name should be.
1276 const char *NamedOutput;
1277 if (JA.getType() == types::TY_Image) {
1278 NamedOutput = DefaultImageName.c_str();
1279 } else {
1280 const char *Suffix = types::getTypeTempSuffix(JA.getType());
1281 assert(Suffix && "All types used for output should have a suffix.");
1282
1283 std::string::size_type End = std::string::npos;
1284 if (!types::appendSuffixForType(JA.getType()))
1285 End = BaseName.rfind('.');
1286 std::string Suffixed(BaseName.substr(0, End));
1287 Suffixed += '.';
1288 Suffixed += Suffix;
1289 NamedOutput = C.getArgs().MakeArgString(Suffixed.c_str());
1290 }
1291
Chad Rosierf8412cd2011-07-15 21:54:29 +00001292 // If we're saving temps and the temp filename conflicts with the input
1293 // filename, then avoid overwriting input file.
1294 if (!AtTopLevel && C.getArgs().hasArg(options::OPT_save_temps) &&
1295 NamedOutput == BaseName) {
1296 std::string TmpName =
1297 GetTemporaryPath(types::getTypeTempSuffix(JA.getType()));
1298 return C.addTempFile(C.getArgs().MakeArgString(TmpName.c_str()));
1299 }
1300
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001301 // As an annoying special case, PCH generation doesn't strip the pathname.
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001302 if (JA.getType() == types::TY_PCH) {
Michael J. Spencere1696752010-12-18 00:19:12 +00001303 llvm::sys::path::remove_filename(BasePath);
1304 if (BasePath.empty())
Daniel Dunbare6c83192009-03-18 09:58:30 +00001305 BasePath = NamedOutput;
1306 else
Michael J. Spencere1696752010-12-18 00:19:12 +00001307 llvm::sys::path::append(BasePath, NamedOutput);
Daniel Dunbar7a178a42009-03-17 17:53:55 +00001308 return C.addResultFile(C.getArgs().MakeArgString(BasePath.c_str()));
1309 } else {
1310 return C.addResultFile(NamedOutput);
1311 }
1312}
1313
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001314std::string Driver::GetFilePath(const char *Name, const ToolChain &TC) const {
Chandler Carruth84559242010-03-22 01:52:07 +00001315 // Respect a limited subset of the '-Bprefix' functionality in GCC by
1316 // attempting to use this prefix when lokup up program paths.
Benjamin Kramer1a648d12011-02-08 20:31:42 +00001317 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1318 ie = PrefixDirs.end(); it != ie; ++it) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00001319 std::string Dir(*it);
1320 if (Dir.empty())
1321 continue;
1322 if (Dir[0] == '=')
1323 Dir = SysRoot + Dir.substr(1);
1324 llvm::sys::Path P(Dir);
Chandler Carruth84559242010-03-22 01:52:07 +00001325 P.appendComponent(Name);
Michael J. Spencerf6efe582011-01-10 02:34:13 +00001326 bool Exists;
1327 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Chandler Carruth84559242010-03-22 01:52:07 +00001328 return P.str();
1329 }
1330
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001331 const ToolChain::path_list &List = TC.getFilePaths();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001332 for (ToolChain::path_list::const_iterator
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001333 it = List.begin(), ie = List.end(); it != ie; ++it) {
Joerg Sonnenberger6165ab12011-03-21 13:51:29 +00001334 std::string Dir(*it);
1335 if (Dir.empty())
1336 continue;
1337 if (Dir[0] == '=')
1338 Dir = SysRoot + Dir.substr(1);
1339 llvm::sys::Path P(Dir);
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001340 P.appendComponent(Name);
Michael J. Spencerf6efe582011-01-10 02:34:13 +00001341 bool Exists;
1342 if (!llvm::sys::fs::exists(P.str(), Exists) && Exists)
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001343 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001344 }
1345
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001346 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001347}
1348
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001349std::string Driver::GetProgramPath(const char *Name, const ToolChain &TC,
1350 bool WantFile) const {
Chandler Carruth84559242010-03-22 01:52:07 +00001351 // Respect a limited subset of the '-Bprefix' functionality in GCC by
1352 // attempting to use this prefix when lokup up program paths.
Benjamin Kramer1a648d12011-02-08 20:31:42 +00001353 for (Driver::prefix_list::const_iterator it = PrefixDirs.begin(),
1354 ie = PrefixDirs.end(); it != ie; ++it) {
1355 llvm::sys::Path P(*it);
Chandler Carruth84559242010-03-22 01:52:07 +00001356 P.appendComponent(Name);
Michael J. Spencerf6efe582011-01-10 02:34:13 +00001357 bool Exists;
1358 if (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists
1359 : P.canExecute())
Chandler Carruth84559242010-03-22 01:52:07 +00001360 return P.str();
1361 }
1362
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001363 const ToolChain::path_list &List = TC.getProgramPaths();
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001364 for (ToolChain::path_list::const_iterator
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001365 it = List.begin(), ie = List.end(); it != ie; ++it) {
1366 llvm::sys::Path P(*it);
1367 P.appendComponent(Name);
Michael J. Spencerf6efe582011-01-10 02:34:13 +00001368 bool Exists;
1369 if (WantFile ? !llvm::sys::fs::exists(P.str(), Exists) && Exists
1370 : P.canExecute())
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001371 return P.str();
Daniel Dunbar68b01a02009-03-18 20:26:19 +00001372 }
1373
Daniel Dunbar76ce7412009-03-23 16:15:50 +00001374 // If all else failed, search the path.
1375 llvm::sys::Path P(llvm::sys::Program::FindProgramByName(Name));
Daniel Dunbar6f668772009-03-18 21:34:08 +00001376 if (!P.empty())
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001377 return P.str();
Daniel Dunbar6f668772009-03-18 21:34:08 +00001378
Daniel Dunbar1ce81532009-09-09 22:33:00 +00001379 return Name;
Daniel Dunbar5e0f6af2009-03-13 00:51:18 +00001380}
1381
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001382std::string Driver::GetTemporaryPath(const char *Suffix) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001383 // FIXME: This is lame; sys::Path should provide this function (in particular,
1384 // it should know how to find the temporary files dir).
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001385 std::string Error;
Daniel Dunbarc35694d2009-04-20 20:28:21 +00001386 const char *TmpDir = ::getenv("TMPDIR");
1387 if (!TmpDir)
1388 TmpDir = ::getenv("TEMP");
1389 if (!TmpDir)
Daniel Dunbar712e4de2009-04-21 00:25:10 +00001390 TmpDir = ::getenv("TMP");
1391 if (!TmpDir)
Daniel Dunbarc35694d2009-04-20 20:28:21 +00001392 TmpDir = "/tmp";
1393 llvm::sys::Path P(TmpDir);
Daniel Dunbarab8ce7c2009-04-20 17:32:49 +00001394 P.appendComponent("cc");
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001395 if (P.makeUnique(false, &Error)) {
1396 Diag(clang::diag::err_drv_unable_to_make_temp) << Error;
1397 return "";
1398 }
1399
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001400 // FIXME: Grumble, makeUnique sometimes leaves the file around!? PR3837.
Daniel Dunbar18d69de2009-03-18 23:08:52 +00001401 P.eraseFromDisk(false, 0);
1402
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001403 P.appendSuffix(Suffix);
Chris Lattner3441b4f2009-08-23 22:45:33 +00001404 return P.str();
Daniel Dunbare627c1c2009-03-18 19:34:39 +00001405}
1406
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001407const HostInfo *Driver::GetHostInfo(const char *TripleStr) const {
Daniel Dunbar2608c542009-03-18 01:38:48 +00001408 llvm::PrettyStackTraceString CrashInfo("Constructing host");
Anton Korobeynikova9ff8572011-03-05 16:05:17 +00001409 llvm::Triple Triple(llvm::Triple::normalize(TripleStr).c_str());
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00001410
Chris Lattner09797542010-03-04 21:07:38 +00001411 // TCE is an osless target
1412 if (Triple.getArchName() == "tce")
Daniel Dunbarfb3d7472010-06-14 21:23:12 +00001413 return createTCEHostInfo(*this, Triple);
Chris Lattner09797542010-03-04 21:07:38 +00001414
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001415 switch (Triple.getOS()) {
Edward O'Callaghan856e4ff2009-08-22 01:06:46 +00001416 case llvm::Triple::AuroraUX:
1417 return createAuroraUXHostInfo(*this, Triple);
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001418 case llvm::Triple::Darwin:
1419 return createDarwinHostInfo(*this, Triple);
1420 case llvm::Triple::DragonFly:
1421 return createDragonFlyHostInfo(*this, Triple);
Daniel Dunbar10de9e62009-06-29 20:52:51 +00001422 case llvm::Triple::OpenBSD:
1423 return createOpenBSDHostInfo(*this, Triple);
Benjamin Kramer24f1d3e2011-02-02 18:59:27 +00001424 case llvm::Triple::NetBSD:
1425 return createNetBSDHostInfo(*this, Triple);
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001426 case llvm::Triple::FreeBSD:
1427 return createFreeBSDHostInfo(*this, Triple);
Chris Lattner3e2ee142010-07-07 16:01:42 +00001428 case llvm::Triple::Minix:
1429 return createMinixHostInfo(*this, Triple);
Eli Friedman5cd659f2009-05-26 07:52:18 +00001430 case llvm::Triple::Linux:
1431 return createLinuxHostInfo(*this, Triple);
Michael J. Spencerb186bc32010-08-21 21:55:07 +00001432 case llvm::Triple::Win32:
1433 return createWindowsHostInfo(*this, Triple);
1434 case llvm::Triple::MinGW32:
Michael J. Spencerb186bc32010-08-21 21:55:07 +00001435 return createMinGWHostInfo(*this, Triple);
Daniel Dunbar51c7f972009-05-22 02:53:45 +00001436 default:
1437 return createUnknownHostInfo(*this, Triple);
1438 }
Daniel Dunbar4dff6a42009-03-10 23:41:59 +00001439}
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001440
1441bool Driver::ShouldUseClangCompiler(const Compilation &C, const JobAction &JA,
Daniel Dunbar953b8d12009-09-08 23:36:55 +00001442 const llvm::Triple &Triple) const {
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001443 // Check if user requested no clang, or clang doesn't understand this type (we
1444 // only handle single inputs for now).
Daniel Dunbar6cdf83c2009-09-01 16:57:46 +00001445 if (!CCCUseClang || JA.size() != 1 ||
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001446 !types::isAcceptedByClang((*JA.begin())->getType()))
1447 return false;
1448
Daniel Dunbar88f356e2009-03-24 19:02:31 +00001449 // Otherwise make sure this is an action clang understands.
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001450 if (isa<PreprocessJobAction>(JA)) {
Daniel Dunbar6b5244d2009-03-24 19:14:56 +00001451 if (!CCCUseClangCPP) {
1452 Diag(clang::diag::warn_drv_not_using_clang_cpp);
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001453 return false;
Daniel Dunbar6b5244d2009-03-24 19:14:56 +00001454 }
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001455 } else if (!isa<PrecompileJobAction>(JA) && !isa<CompileJobAction>(JA))
1456 return false;
1457
Daniel Dunbar88f356e2009-03-24 19:02:31 +00001458 // Use clang for C++?
Daniel Dunbar6b5244d2009-03-24 19:14:56 +00001459 if (!CCCUseClangCXX && types::isCXX((*JA.begin())->getType())) {
1460 Diag(clang::diag::warn_drv_not_using_clang_cxx);
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001461 return false;
Daniel Dunbar6b5244d2009-03-24 19:14:56 +00001462 }
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001463
Daniel Dunbaraeea8ac2010-02-11 03:16:21 +00001464 // Always use clang for precompiling, AST generation, and rewriting,
1465 // regardless of archs.
Daniel Dunbar24e52992010-06-07 23:28:45 +00001466 if (isa<PrecompileJobAction>(JA) ||
1467 types::isOnlyAcceptedByClang(JA.getType()))
Daniel Dunbarf2df7c22009-04-16 23:10:13 +00001468 return true;
1469
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001470 // Finally, don't use clang if this isn't one of the user specified archs to
1471 // build.
Daniel Dunbar953b8d12009-09-08 23:36:55 +00001472 if (!CCCClangArchs.empty() && !CCCClangArchs.count(Triple.getArch())) {
1473 Diag(clang::diag::warn_drv_not_using_clang_arch) << Triple.getArchName();
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001474 return false;
Daniel Dunbar6b5244d2009-03-24 19:14:56 +00001475 }
Daniel Dunbar8fa879d2009-03-24 18:57:02 +00001476
1477 return true;
1478}
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001479
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001480/// GetReleaseVersion - Parse (([0-9]+)(.([0-9]+)(.([0-9]+)?))?)? and return the
1481/// grouped values as integers. Numbers which are not provided are set to 0.
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001482///
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001483/// \return True if the entire string was parsed (9.2), or all groups were
1484/// parsed (10.3.5extrastuff).
1485bool Driver::GetReleaseVersion(const char *Str, unsigned &Major,
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001486 unsigned &Minor, unsigned &Micro,
1487 bool &HadExtra) {
1488 HadExtra = false;
1489
1490 Major = Minor = Micro = 0;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001491 if (*Str == '\0')
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001492 return true;
1493
1494 char *End;
1495 Major = (unsigned) strtol(Str, &End, 10);
1496 if (*Str != '\0' && *End == '\0')
1497 return true;
1498 if (*End != '.')
1499 return false;
Daniel Dunbarf26a7ab2009-09-08 23:36:43 +00001500
Daniel Dunbarc7fd57a2009-03-26 15:58:36 +00001501 Str = End+1;
1502 Minor = (unsigned) strtol(Str, &End, 10);
1503 if (*Str != '\0' && *End == '\0')
1504 return true;
1505 if (*End != '.')
1506 return false;
1507
1508 Str = End+1;
1509 Micro = (unsigned) strtol(Str, &End, 10);
1510 if (*Str != '\0' && *End == '\0')
1511 return true;
1512 if (Str == End)
1513 return false;
1514 HadExtra = true;
1515 return true;
1516}