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