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/ADT/StringSwitch.h"
21 #include "llvm/Support/raw_ostream.h"
22 #include "llvm/Support/Program.h"
23 #include <sys/stat.h>
24 #include <errno.h>
25 
26 using namespace clang::driver;
27 using namespace clang;
28 
29 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
30                          InputArgList *_Args, DerivedArgList *_TranslatedArgs)
31   : TheDriver(D), DefaultToolChain(_DefaultToolChain), Args(_Args),
32     TranslatedArgs(_TranslatedArgs), Redirects(0) {
33 }
34 
35 Compilation::~Compilation() {
36   delete TranslatedArgs;
37   delete Args;
38 
39   // Free any derived arg lists.
40   for (llvm::DenseMap<std::pair<const ToolChain*, const char*>,
41                       DerivedArgList*>::iterator it = TCArgs.begin(),
42          ie = TCArgs.end(); it != ie; ++it)
43     if (it->second != TranslatedArgs)
44       delete it->second;
45 
46   // Free the actions, if built.
47   for (ActionList::iterator it = Actions.begin(), ie = Actions.end();
48        it != ie; ++it)
49     delete *it;
50 
51   // Free redirections of stdout/stderr.
52   if (Redirects) {
53     delete Redirects[1];
54     delete Redirects[2];
55     delete [] Redirects;
56   }
57 }
58 
59 const DerivedArgList &Compilation::getArgsForToolChain(const ToolChain *TC,
60                                                        const char *BoundArch) {
61   if (!TC)
62     TC = &DefaultToolChain;
63 
64   DerivedArgList *&Entry = TCArgs[std::make_pair(TC, BoundArch)];
65   if (!Entry) {
66     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
67     if (!Entry)
68       Entry = TranslatedArgs;
69   }
70 
71   return *Entry;
72 }
73 
74 void Compilation::PrintJob(raw_ostream &OS, const Job &J,
75                            const char *Terminator, bool Quote) const {
76   if (const Command *C = dyn_cast<Command>(&J)) {
77     OS << " \"" << C->getExecutable() << '"';
78     for (ArgStringList::const_iterator it = C->getArguments().begin(),
79            ie = C->getArguments().end(); it != ie; ++it) {
80       OS << ' ';
81       if (!Quote && !std::strpbrk(*it, " \"\\$")) {
82         OS << *it;
83         continue;
84       }
85 
86       // Quote the argument and escape shell special characters; this isn't
87       // really complete but is good enough.
88       OS << '"';
89       for (const char *s = *it; *s; ++s) {
90         if (*s == '"' || *s == '\\' || *s == '$')
91           OS << '\\';
92         OS << *s;
93       }
94       OS << '"';
95     }
96     OS << Terminator;
97   } else {
98     const JobList *Jobs = cast<JobList>(&J);
99     for (JobList::const_iterator
100            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
101       PrintJob(OS, **it, Terminator, Quote);
102   }
103 }
104 
105 static bool skipArg(const char *Flag, bool &SkipNextArg) {
106   StringRef FlagRef(Flag);
107 
108   // Assume we're going to see -Flag <Arg>.
109   SkipNextArg = true;
110 
111   // These flags are all of the form -Flag <Arg> and are treated as two
112   // arguments.  Therefore, we need to skip the flag and the next argument.
113   bool Res = llvm::StringSwitch<bool>(Flag)
114     .Cases("-I", "-MF", "-MT", "-MQ", true)
115     .Cases("-o", "-coverage-file", "-dependency-file", true)
116     .Cases("-fdebug-compilation-dir", "-fmodule-cache-path", "-idirafter", true)
117     .Cases("-include", "-include-pch", "-internal-isystem", true)
118     .Cases("-internal-externc-isystem", "-iprefix", "-iwithprefix", true)
119     .Cases("-iwithprefixbefore", "-isysroot", "-isystem", "-iquote", true)
120     .Cases("-resource-dir", "-serialize-diagnostic-file", true)
121     .Case("-dwarf-debug-flags", true)
122     .Default(false);
123 
124   // Match found.
125   if (Res)
126     return Res;
127 
128   // The remaining flags are treated as a single argument.
129   SkipNextArg = false;
130 
131   // These flags are all of the form -Flag and have no second argument.
132   Res = llvm::StringSwitch<bool>(Flag)
133     .Cases("-M", "-MM", "-MG", "-MP", "-MD", true)
134     .Case("-MMD", true)
135     .Default(false);
136 
137   // Match found.
138   if (Res)
139     return Res;
140 
141   // These flags are treated as a single argument (e.g., -F<Dir>).
142   if (FlagRef.startswith("-F") || FlagRef.startswith("-I"))
143     return true;
144 
145   return false;
146 }
147 
148 static bool quoteNextArg(const char *flag) {
149   return llvm::StringSwitch<bool>(flag)
150     .Case("-D", true)
151     .Default(false);
152 }
153 
154 void Compilation::PrintDiagnosticJob(raw_ostream &OS, const Job &J) const {
155   if (const Command *C = dyn_cast<Command>(&J)) {
156     OS << C->getExecutable();
157     unsigned QuoteNextArg = 0;
158     for (ArgStringList::const_iterator it = C->getArguments().begin(),
159            ie = C->getArguments().end(); it != ie; ++it) {
160 
161       bool SkipNext;
162       if (skipArg(*it, SkipNext)) {
163         if (SkipNext) ++it;
164         continue;
165       }
166 
167       if (!QuoteNextArg)
168         QuoteNextArg = quoteNextArg(*it) ? 2 : 0;
169 
170       OS << ' ';
171 
172       if (QuoteNextArg == 1)
173         OS << '"';
174 
175       if (!std::strpbrk(*it, " \"\\$")) {
176         OS << *it;
177       } else {
178         // Quote the argument and escape shell special characters; this isn't
179         // really complete but is good enough.
180         OS << '"';
181         for (const char *s = *it; *s; ++s) {
182           if (*s == '"' || *s == '\\' || *s == '$')
183             OS << '\\';
184           OS << *s;
185         }
186         OS << '"';
187       }
188 
189       if (QuoteNextArg) {
190         if (QuoteNextArg == 1)
191           OS << '"';
192         --QuoteNextArg;
193       }
194     }
195     OS << '\n';
196   } else {
197     const JobList *Jobs = cast<JobList>(&J);
198     for (JobList::const_iterator
199            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
200       PrintDiagnosticJob(OS, **it);
201   }
202 }
203 
204 bool Compilation::CleanupFileList(const ArgStringList &Files,
205                                   bool IssueErrors) const {
206   bool Success = true;
207 
208   for (ArgStringList::const_iterator
209          it = Files.begin(), ie = Files.end(); it != ie; ++it) {
210 
211     llvm::sys::Path P(*it);
212     std::string Error;
213 
214     // Don't try to remove files which we don't have write access to (but may be
215     // able to remove). Underlying tools may have intentionally not overwritten
216     // them.
217     if (!P.canWrite())
218       continue;
219 
220     if (P.eraseFromDisk(false, &Error)) {
221       // Failure is only failure if the file exists and is "regular". There is
222       // a race condition here due to the limited interface of
223       // llvm::sys::Path, we want to know if the removal gave ENOENT.
224 
225       // FIXME: Grumble, P.exists() is broken. PR3837.
226       struct stat buf;
227       if (::stat(P.c_str(), &buf) == 0 ? (buf.st_mode & S_IFMT) == S_IFREG :
228                                          (errno != ENOENT)) {
229         if (IssueErrors)
230           getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
231             << Error;
232         Success = false;
233       }
234     }
235   }
236 
237   return Success;
238 }
239 
240 int Compilation::ExecuteCommand(const Command &C,
241                                 const Command *&FailingCommand) const {
242   llvm::sys::Path Prog(C.getExecutable());
243   const char **Argv = new const char*[C.getArguments().size() + 2];
244   Argv[0] = C.getExecutable();
245   std::copy(C.getArguments().begin(), C.getArguments().end(), Argv+1);
246   Argv[C.getArguments().size() + 1] = 0;
247 
248   if ((getDriver().CCCEcho || getDriver().CCPrintOptions ||
249        getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {
250     raw_ostream *OS = &llvm::errs();
251 
252     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
253     // output stream.
254     if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
255       std::string Error;
256       OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename,
257                                     Error,
258                                     llvm::raw_fd_ostream::F_Append);
259       if (!Error.empty()) {
260         getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
261           << Error;
262         FailingCommand = &C;
263         delete OS;
264         return 1;
265       }
266     }
267 
268     if (getDriver().CCPrintOptions)
269       *OS << "[Logging clang options]";
270 
271     PrintJob(*OS, C, "\n", /*Quote=*/getDriver().CCPrintOptions);
272 
273     if (OS != &llvm::errs())
274       delete OS;
275   }
276 
277   std::string Error;
278   int Res =
279     llvm::sys::Program::ExecuteAndWait(Prog, Argv,
280                                        /*env*/0, Redirects,
281                                        /*secondsToWait*/0, /*memoryLimit*/0,
282                                        &Error);
283   if (!Error.empty()) {
284     assert(Res && "Error string set with 0 result code!");
285     getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
286   }
287 
288   if (Res)
289     FailingCommand = &C;
290 
291   delete[] Argv;
292   return Res;
293 }
294 
295 int Compilation::ExecuteJob(const Job &J,
296                             const Command *&FailingCommand) const {
297   if (const Command *C = dyn_cast<Command>(&J)) {
298     return ExecuteCommand(*C, FailingCommand);
299   } else {
300     const JobList *Jobs = cast<JobList>(&J);
301     for (JobList::const_iterator
302            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
303       if (int Res = ExecuteJob(**it, FailingCommand))
304         return Res;
305     return 0;
306   }
307 }
308 
309 void Compilation::initCompilationForDiagnostics(void) {
310   // Free actions and jobs.
311   DeleteContainerPointers(Actions);
312   Jobs.clear();
313 
314   // Clear temporary/results file lists.
315   TempFiles.clear();
316   ResultFiles.clear();
317 
318   // Remove any user specified output.  Claim any unclaimed arguments, so as
319   // to avoid emitting warnings about unused args.
320   OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD,
321                                 options::OPT_MMD };
322   for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) {
323     if (TranslatedArgs->hasArg(OutputOpts[i]))
324       TranslatedArgs->eraseArg(OutputOpts[i]);
325   }
326   TranslatedArgs->ClaimAllArgs();
327 
328   // Redirect stdout/stderr to /dev/null.
329   Redirects = new const llvm::sys::Path*[3]();
330   Redirects[1] = new const llvm::sys::Path();
331   Redirects[2] = new const llvm::sys::Path();
332 }
333 
334 StringRef Compilation::getSysRoot(void) const {
335   return getDriver().SysRoot;
336 }
337