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/Driver.h"
13 #include "clang/Driver/DriverDiagnostic.h"
14 #include "clang/Driver/Options.h"
15 #include "clang/Driver/ToolChain.h"
16 #include "llvm/ADT/STLExtras.h"
17 #include "llvm/Option/ArgList.h"
18 #include "llvm/Support/FileSystem.h"
19 #include "llvm/Support/raw_ostream.h"
20 
21 using namespace clang::driver;
22 using namespace clang;
23 using namespace llvm::opt;
24 
25 Compilation::Compilation(const Driver &D, const ToolChain &_DefaultToolChain,
26                          InputArgList *_Args, DerivedArgList *_TranslatedArgs)
27     : TheDriver(D), DefaultToolChain(_DefaultToolChain),
28       CudaHostToolChain(&DefaultToolChain), CudaDeviceToolChain(nullptr),
29       Args(_Args), TranslatedArgs(_TranslatedArgs), Redirects(nullptr),
30       ForDiagnostics(false) {}
31 
32 Compilation::~Compilation() {
33   delete TranslatedArgs;
34   delete Args;
35 
36   // Free any derived arg lists.
37   for (llvm::DenseMap<std::pair<const ToolChain*, const char*>,
38                       DerivedArgList*>::iterator it = TCArgs.begin(),
39          ie = TCArgs.end(); it != ie; ++it)
40     if (it->second != TranslatedArgs)
41       delete it->second;
42 
43   // Free redirections of stdout/stderr.
44   if (Redirects) {
45     delete Redirects[1];
46     delete Redirects[2];
47     delete [] Redirects;
48   }
49 }
50 
51 const DerivedArgList &Compilation::getArgsForToolChain(const ToolChain *TC,
52                                                        const char *BoundArch) {
53   if (!TC)
54     TC = &DefaultToolChain;
55 
56   DerivedArgList *&Entry = TCArgs[std::make_pair(TC, BoundArch)];
57   if (!Entry) {
58     Entry = TC->TranslateArgs(*TranslatedArgs, BoundArch);
59     if (!Entry)
60       Entry = TranslatedArgs;
61   }
62 
63   return *Entry;
64 }
65 
66 bool Compilation::CleanupFile(const char *File, bool IssueErrors) const {
67   // FIXME: Why are we trying to remove files that we have not created? For
68   // example we should only try to remove a temporary assembly file if
69   // "clang -cc1" succeed in writing it. Was this a workaround for when
70   // clang was writing directly to a .s file and sometimes leaving it behind
71   // during a failure?
72 
73   // FIXME: If this is necessary, we can still try to split
74   // llvm::sys::fs::remove into a removeFile and a removeDir and avoid the
75   // duplicated stat from is_regular_file.
76 
77   // Don't try to remove files which we don't have write access to (but may be
78   // able to remove), or non-regular files. Underlying tools may have
79   // intentionally not overwritten them.
80   if (!llvm::sys::fs::can_write(File) || !llvm::sys::fs::is_regular_file(File))
81     return true;
82 
83   if (std::error_code EC = llvm::sys::fs::remove(File)) {
84     // Failure is only failure if the file exists and is "regular". We checked
85     // for it being regular before, and llvm::sys::fs::remove ignores ENOENT,
86     // so we don't need to check again.
87 
88     if (IssueErrors)
89       getDriver().Diag(clang::diag::err_drv_unable_to_remove_file)
90         << EC.message();
91     return false;
92   }
93   return true;
94 }
95 
96 bool Compilation::CleanupFileList(const ArgStringList &Files,
97                                   bool IssueErrors) const {
98   bool Success = true;
99   for (ArgStringList::const_iterator
100          it = Files.begin(), ie = Files.end(); it != ie; ++it)
101     Success &= CleanupFile(*it, IssueErrors);
102   return Success;
103 }
104 
105 bool Compilation::CleanupFileMap(const ArgStringMap &Files,
106                                  const JobAction *JA,
107                                  bool IssueErrors) const {
108   bool Success = true;
109   for (ArgStringMap::const_iterator
110          it = Files.begin(), ie = Files.end(); it != ie; ++it) {
111 
112     // If specified, only delete the files associated with the JobAction.
113     // Otherwise, delete all files in the map.
114     if (JA && it->first != JA)
115       continue;
116     Success &= CleanupFile(it->second, IssueErrors);
117   }
118   return Success;
119 }
120 
121 int Compilation::ExecuteCommand(const Command &C,
122                                 const Command *&FailingCommand) const {
123   if ((getDriver().CCPrintOptions ||
124        getArgs().hasArg(options::OPT_v)) && !getDriver().CCGenDiagnostics) {
125     raw_ostream *OS = &llvm::errs();
126 
127     // Follow gcc implementation of CC_PRINT_OPTIONS; we could also cache the
128     // output stream.
129     if (getDriver().CCPrintOptions && getDriver().CCPrintOptionsFilename) {
130       std::error_code EC;
131       OS = new llvm::raw_fd_ostream(getDriver().CCPrintOptionsFilename, EC,
132                                     llvm::sys::fs::F_Append |
133                                         llvm::sys::fs::F_Text);
134       if (EC) {
135         getDriver().Diag(clang::diag::err_drv_cc_print_options_failure)
136             << EC.message();
137         FailingCommand = &C;
138         delete OS;
139         return 1;
140       }
141     }
142 
143     if (getDriver().CCPrintOptions)
144       *OS << "[Logging clang options]";
145 
146     C.Print(*OS, "\n", /*Quote=*/getDriver().CCPrintOptions);
147 
148     if (OS != &llvm::errs())
149       delete OS;
150   }
151 
152   std::string Error;
153   bool ExecutionFailed;
154   int Res = C.Execute(Redirects, &Error, &ExecutionFailed);
155   if (!Error.empty()) {
156     assert(Res && "Error string set with 0 result code!");
157     getDriver().Diag(clang::diag::err_drv_command_failure) << Error;
158   }
159 
160   if (Res)
161     FailingCommand = &C;
162 
163   return ExecutionFailed ? 1 : Res;
164 }
165 
166 void Compilation::ExecuteJobs(
167     const JobList &Jobs,
168     SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) const {
169   for (const auto &Job : Jobs) {
170     const Command *FailingCommand = nullptr;
171     if (int Res = ExecuteCommand(Job, FailingCommand)) {
172       FailingCommands.push_back(std::make_pair(Res, FailingCommand));
173       // Bail as soon as one command fails, so we don't output duplicate error
174       // messages if we die on e.g. the same file.
175       return;
176     }
177   }
178 }
179 
180 void Compilation::initCompilationForDiagnostics() {
181   ForDiagnostics = true;
182 
183   // Free actions and jobs.
184   Actions.clear();
185   AllActions.clear();
186   Jobs.clear();
187 
188   // Clear temporary/results file lists.
189   TempFiles.clear();
190   ResultFiles.clear();
191   FailureResultFiles.clear();
192 
193   // Remove any user specified output.  Claim any unclaimed arguments, so as
194   // to avoid emitting warnings about unused args.
195   OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD,
196                                 options::OPT_MMD };
197   for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) {
198     if (TranslatedArgs->hasArg(OutputOpts[i]))
199       TranslatedArgs->eraseArg(OutputOpts[i]);
200   }
201   TranslatedArgs->ClaimAllArgs();
202 
203   // Redirect stdout/stderr to /dev/null.
204   Redirects = new const StringRef*[3]();
205   Redirects[0] = nullptr;
206   Redirects[1] = new StringRef();
207   Redirects[2] = new StringRef();
208 }
209 
210 StringRef Compilation::getSysRoot() const {
211   return getDriver().SysRoot;
212 }
213