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 21using namespace clang::driver; 22using namespace clang; 23using namespace llvm::opt; 24 25Compilation::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 32Compilation::~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 51const 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 66bool 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 96bool 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 105bool 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 121int 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 166typedef SmallVectorImpl< std::pair<int, const Command *> > FailingCommandList; 167 168static bool ActionFailed(const Action *A, 169 const FailingCommandList &FailingCommands) { 170 171 if (FailingCommands.empty()) 172 return false; 173 174 for (FailingCommandList::const_iterator CI = FailingCommands.begin(), 175 CE = FailingCommands.end(); CI != CE; ++CI) 176 if (A == &(CI->second->getSource())) 177 return true; 178 179 for (Action::const_iterator AI = A->begin(), AE = A->end(); AI != AE; ++AI) 180 if (ActionFailed(*AI, FailingCommands)) 181 return true; 182 183 return false; 184} 185 186static bool InputsOk(const Command &C, 187 const FailingCommandList &FailingCommands) { 188 return !ActionFailed(&C.getSource(), FailingCommands); 189} 190 191void Compilation::ExecuteJobs(const JobList &Jobs, 192 FailingCommandList &FailingCommands) const { 193 for (const auto &Job : Jobs) { 194 if (!InputsOk(Job, FailingCommands)) 195 continue; 196 const Command *FailingCommand = nullptr; 197 if (int Res = ExecuteCommand(Job, FailingCommand)) 198 FailingCommands.push_back(std::make_pair(Res, FailingCommand)); 199 } 200} 201 202void Compilation::initCompilationForDiagnostics() { 203 ForDiagnostics = true; 204 205 // Free actions and jobs. 206 Actions.clear(); 207 AllActions.clear(); 208 Jobs.clear(); 209 210 // Clear temporary/results file lists. 211 TempFiles.clear(); 212 ResultFiles.clear(); 213 FailureResultFiles.clear(); 214 215 // Remove any user specified output. Claim any unclaimed arguments, so as 216 // to avoid emitting warnings about unused args. 217 OptSpecifier OutputOpts[] = { options::OPT_o, options::OPT_MD, 218 options::OPT_MMD }; 219 for (unsigned i = 0, e = llvm::array_lengthof(OutputOpts); i != e; ++i) { 220 if (TranslatedArgs->hasArg(OutputOpts[i])) 221 TranslatedArgs->eraseArg(OutputOpts[i]); 222 } 223 TranslatedArgs->ClaimAllArgs(); 224 225 // Redirect stdout/stderr to /dev/null. 226 Redirects = new const StringRef*[3](); 227 Redirects[0] = nullptr; 228 Redirects[1] = new StringRef(); 229 Redirects[2] = new StringRef(); 230} 231 232StringRef Compilation::getSysRoot() const { 233 return getDriver().SysRoot; 234} 235