1 //===--- Compilation.cpp - Compilation Task Implementation ----------------===//
2 //
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
10 #include "clang/Driver/Compilation.h"
11
12 #include "clang/Driver/Action.h"
13 #include "clang/Driver/ArgList.h"
14 #include "clang/Driver/Driver.h"
15 #include "clang/Driver/DriverDiagnostic.h"
16 #include "clang/Driver/Options.h"
17 #include "clang/Driver/ToolChain.h"
18
19 #include "llvm/ADT/STLExtras.h"
20 #include "llvm/Support/raw_ostream.h"
21 #include "llvm/Support/Program.h"
22 #include <sys/stat.h>
23 #include <errno.h>
24
25 using namespace clang::driver;
26 using namespace clang;
27
Compilation(const Driver & D,const ToolChain & _DefaultToolChain,InputArgList * _Args,DerivedArgList * _TranslatedArgs)28 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
29 InputArgList *_Args, DerivedArgList *_TranslatedArgs)
30 : TheDriver(D), DefaultToolChain(_DefaultToolChain), Args(_Args),
31 TranslatedArgs(_TranslatedArgs), Redirects(0) {
32 }
33
~Compilation()34 Compilation::~Compilation() {
35 delete TranslatedArgs;
36 delete Args;
37
38 // Free any derived arg lists.
39 for (llvm::DenseMap<std::pair<const ToolChain*, const char*>,
40 DerivedArgList*>::iterator it = TCArgs.begin(),
41 ie = TCArgs.end(); it != ie; ++it)
42 if (it->second != TranslatedArgs)
43 delete it->second;
44
45 // Free the actions, if built.
46 for (ActionList::iterator it = Actions.begin(), ie = Actions.end();
47 it != ie; ++it)
48 delete *it;
49
50 // Free redirections of stdout/stderr.
51 if (Redirects) {
52 delete Redirects[1];
53 delete Redirects[2];
54 delete [] Redirects;
55 }
56 }
57
getArgsForToolChain(const ToolChain * TC,const char * BoundArch)58 const DerivedArgList &Compilation::getArgsForToolChain(const ToolChain *TC,
59 const char *BoundArch) {
60 if (!TC)
61 TC = &DefaultToolChain;
62
63 DerivedArgList *&Entry = TCArgs[std::make_pair(TC, BoundArch)];
64 if (!Entry) {
65 Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
66 if (!Entry)
67 Entry = TranslatedArgs;
68 }
69
70 return *Entry;
71 }
72
PrintJob(raw_ostream & OS,const Job & J,const char * Terminator,bool Quote) const73 void Compilation::PrintJob(raw_ostream &OS, const Job &J,
74 const char *Terminator, bool Quote) const {
75 if (const Command *C = dyn_cast<Command>(&J)) {
76 OS << " \"" << C->getExecutable() << '"';
77 for (ArgStringList::const_iterator it = C->getArguments().begin(),
78 ie = C->getArguments().end(); it != ie; ++it) {
79 OS << ' ';
80 if (!Quote && !std::strpbrk(*it, " \"\\$")) {
81 OS << *it;
82 continue;
83 }
84
85 // Quote the argument and escape shell special characters; this isn't
86 // really complete but is good enough.
87 OS << '"';
88 for (const char *s = *it; *s; ++s) {
89 if (*s == '"' || *s == '\\' || *s == '$')
90 OS << '\\';
91 OS << *s;
92 }
93 OS << '"';
94 }
95 OS << Terminator;
96 } else {
97 const JobList *Jobs = cast<JobList>(&J);
98 for (JobList::const_iterator
99 it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
100 PrintJob(OS, **it, Terminator, Quote);
101 }
102 }
103
CleanupFileList(const ArgStringList & Files,bool IssueErrors) const104 bool Compilation::CleanupFileList(const ArgStringList &Files,
105 bool IssueErrors) const {
106 bool Success = true;
107
108 for (ArgStringList::const_iterator
109 it = Files.begin(), ie = Files.end(); it != ie; ++it) {
110
111 llvm::sys::Path P(*it);
112 std::string Error;
113
114 // Don't try to remove files which we don't have write access to (but may be
115 // able to remove). Underlying tools may have intentionally not overwritten
116 // them.
117 if (!P.canWrite())
118 continue;
119
120 if (P.eraseFromDisk(false, &Error)) {
121 // Failure is only failure if the file exists and is "regular". There is
122 // a race condition here due to the limited interface of
123 // llvm::sys::Path, we want to know if the removal gave ENOENT.
124
125 // FIXME: Grumble, P.exists() is broken. PR3837.
126 struct stat buf;
127 if (::stat(P.c_str(), &buf) == 0 ? (buf.st_mode & S_IFMT) == S_IFREG :
128 (errno != ENOENT)) {
129 if (IssueErrors)
130 getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
131 << Error;
132 Success = false;
133 }
134 }
135 }
136
137 return Success;
138 }
139
ExecuteCommand(const Command & C,const Command * & FailingCommand) const140 int Compilation::ExecuteCommand(const Command &C,
141 const Command *&FailingCommand) const {
142 llvm::sys::Path Prog(C.getExecutable());
143 const char **Argv = new const char*[C.getArguments().size() + 2];
144 Argv[0] = C.getExecutable();
145 std::copy(C.getArguments().begin(), C.getArguments().end(), Argv+1);
146 Argv[C.getArguments().size() + 1] = 0;
147
148 if ((getDriver().CCCEcho || getDriver().CCPrintOptions ||
149 getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {
150 raw_ostream *OS = &llvm::errs();
151
152 // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
153 // output stream.
154 if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
155 std::string Error;
156 OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename,
157 Error,
158 llvm::raw_fd_ostream::F_Append);
159 if (!Error.empty()) {
160 getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
161 << Error;
162 FailingCommand = &C;
163 delete OS;
164 return 1;
165 }
166 }
167
168 if (getDriver().CCPrintOptions)
169 *OS << "[Logging clang options]";
170
171 PrintJob(*OS, C, "\n", /*Quote=*/getDriver().CCPrintOptions);
172
173 if (OS != &llvm::errs())
174 delete OS;
175 }
176
177 std::string Error;
178 int Res =
179 llvm::sys::Program::ExecuteAndWait(Prog, Argv,
180 /*env*/0, Redirects,
181 /*secondsToWait*/0, /*memoryLimit*/0,
182 &Error);
183 if (!Error.empty()) {
184 assert(Res && "Error string set with 0 result code!");
185 getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
186 }
187
188 if (Res)
189 FailingCommand = &C;
190
191 delete[] Argv;
192 return Res;
193 }
194
ExecuteJob(const Job & J,const Command * & FailingCommand) const195 int Compilation::ExecuteJob(const Job &J,
196 const Command *&FailingCommand) const {
197 if (const Command *C = dyn_cast<Command>(&J)) {
198 return ExecuteCommand(*C, FailingCommand);
199 } else {
200 const JobList *Jobs = cast<JobList>(&J);
201 for (JobList::const_iterator
202 it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
203 if (int Res = ExecuteJob(**it, FailingCommand))
204 return Res;
205 return 0;
206 }
207 }
208
initCompilationForDiagnostics(void)209 void Compilation::initCompilationForDiagnostics(void) {
210 // Free actions and jobs.
211 DeleteContainerPointers(Actions);
212 Jobs.clear();
213
214 // Clear temporary/results file lists.
215 TempFiles.clear();
216 ResultFiles.clear();
217
218 // Remove any user specified output. Claim any unclaimed arguments, so as
219 // to avoid emitting warnings about unused args.
220 OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD,
221 options::OPT_MMD };
222 for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) {
223 if (TranslatedArgs->hasArg(OutputOpts[i]))
224 TranslatedArgs->eraseArg(OutputOpts[i]);
225 }
226 TranslatedArgs->ClaimAllArgs();
227
228 // Redirect stdout/stderr to /dev/null.
229 Redirects = new const llvm::sys::Path*[3]();
230 Redirects[1] = new const llvm::sys::Path();
231 Redirects[2] = new const llvm::sys::Path();
232 }
233
getSysRoot(void) const234 StringRef Compilation::getSysRoot(void) const {
235 return getDriver().SysRoot;
236 }
237