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/Support/raw_ostream.h"
20 #include "llvm/Support/Program.h"
21 #include <sys/stat.h>
22 #include <errno.h>
23 using namespace clang::driver;
24 
25 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
26                          InputArgList *_Args, DerivedArgList *_TranslatedArgs)
27   : TheDriver(D), DefaultToolChain(_DefaultToolChain), Args(_Args),
28     TranslatedArgs(_TranslatedArgs) {
29 }
30 
31 Compilation::~Compilation() {
32   delete TranslatedArgs;
33   delete Args;
34 
35   // Free any derived arg lists.
36   for (llvm::DenseMap<std::pair<const ToolChain*, const char*>,
37                       DerivedArgList*>::iterator it = TCArgs.begin(),
38          ie = TCArgs.end(); it != ie; ++it)
39     if (it->second != TranslatedArgs)
40       delete it->second;
41 
42   // Free the actions, if built.
43   for (ActionList::iterator it = Actions.begin(), ie = Actions.end();
44        it != ie; ++it)
45     delete *it;
46 }
47 
48 const DerivedArgList &Compilation::getArgsForToolChain(const ToolChain *TC,
49                                                        const char *BoundArch) {
50   if (!TC)
51     TC = &DefaultToolChain;
52 
53   DerivedArgList *&Entry = TCArgs[std::make_pair(TC, BoundArch)];
54   if (!Entry) {
55     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
56     if (!Entry)
57       Entry = TranslatedArgs;
58   }
59 
60   return *Entry;
61 }
62 
63 void Compilation::PrintJob(llvm::raw_ostream &OS, const Job &J,
64                            const char *Terminator, bool Quote) const {
65   if (const Command *C = dyn_cast<Command>(&J)) {
66     OS << " \"" << C->getExecutable() << '"';
67     for (ArgStringList::const_iterator it = C->getArguments().begin(),
68            ie = C->getArguments().end(); it != ie; ++it) {
69       OS << ' ';
70       if (!Quote) {
71         OS << *it;
72         continue;
73       }
74 
75       // Quote the argument and escape shell special characters; this isn't
76       // really complete but is good enough.
77       OS << '"';
78       for (const char *s = *it; *s; ++s) {
79         if (*s == '"' || *s == '\\' || *s == '$')
80           OS << '\\';
81         OS << *s;
82       }
83       OS << '"';
84     }
85     OS << Terminator;
86   } else {
87     const JobList *Jobs = cast<JobList>(&J);
88     for (JobList::const_iterator
89            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
90       PrintJob(OS, **it, Terminator, Quote);
91   }
92 }
93 
94 bool Compilation::CleanupFileList(const ArgStringList &Files,
95                                   bool IssueErrors) const {
96   bool Success = true;
97 
98   for (ArgStringList::const_iterator
99          it = Files.begin(), ie = Files.end(); it != ie; ++it) {
100 
101     llvm::sys::Path P(*it);
102     std::string Error;
103 
104     if (P.eraseFromDisk(false, &Error)) {
105       // Failure is only failure if the file exists and is "regular". There is
106       // a race condition here due to the limited interface of
107       // llvm::sys::Path, we want to know if the removal gave ENOENT.
108 
109       // FIXME: Grumble, P.exists() is broken. PR3837.
110       struct stat buf;
111       if (::stat(P.c_str(), &buf) == 0 ? (buf.st_mode & S_IFMT) == S_IFREG :
112                                          (errno != ENOENT)) {
113         if (IssueErrors)
114           getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
115             << Error;
116         Success = false;
117       }
118     }
119   }
120 
121   return Success;
122 }
123 
124 int Compilation::ExecuteCommand(const Command &C,
125                                 const Command *&FailingCommand) const {
126   llvm::sys::Path Prog(C.getExecutable());
127   const char **Argv = new const char*[C.getArguments().size() + 2];
128   Argv[0] = C.getExecutable();
129   std::copy(C.getArguments().begin(), C.getArguments().end(), Argv+1);
130   Argv[C.getArguments().size() + 1] = 0;
131 
132   if (getDriver().CCCEcho || getDriver().CCPrintOptions ||
133       getArgs().hasArg(options::OPT_v)) {
134     llvm::raw_ostream *OS = &llvm::errs();
135 
136     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
137     // output stream.
138     if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
139       std::string Error;
140       OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename,
141                                     Error,
142                                     llvm::raw_fd_ostream::F_Append);
143       if (!Error.empty()) {
144         getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
145           << Error;
146         FailingCommand = &C;
147         delete OS;
148         return 1;
149       }
150     }
151 
152     if (getDriver().CCPrintOptions)
153       *OS << "[Logging clang options]";
154 
155     PrintJob(*OS, C, "\n", /*Quote=*/getDriver().CCPrintOptions);
156 
157     if (OS != &llvm::errs())
158       delete OS;
159   }
160 
161   std::string Error;
162   int Res =
163     llvm::sys::Program::ExecuteAndWait(Prog, Argv,
164                                        /*env*/0, /*redirects*/0,
165                                        /*secondsToWait*/0, /*memoryLimit*/0,
166                                        &Error);
167   if (!Error.empty()) {
168     assert(Res && "Error string set with 0 result code!");
169     getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
170   }
171 
172   if (Res)
173     FailingCommand = &C;
174 
175   delete[] Argv;
176   return Res;
177 }
178 
179 int Compilation::ExecuteJob(const Job &J,
180                             const Command *&FailingCommand) const {
181   if (const Command *C = dyn_cast<Command>(&J)) {
182     return ExecuteCommand(*C, FailingCommand);
183   } else {
184     const JobList *Jobs = cast<JobList>(&J);
185     for (JobList::const_iterator
186            it = Jobs->begin(), ie = Jobs->end(); it != ie; ++it)
187       if (int Res = ExecuteJob(**it, FailingCommand))
188         return Res;
189     return 0;
190   }
191 }
192