1 //===- Compilation.h - Compilation Task Data Structure ----------*- C++ -*-===// 2 // 3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. 4 // See https://llvm.org/LICENSE.txt for license information. 5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception 6 // 7 //===----------------------------------------------------------------------===// 8 9 #ifndef LLVM_CLANG_DRIVER_COMPILATION_H 10 #define LLVM_CLANG_DRIVER_COMPILATION_H 11 12 #include "clang/Basic/LLVM.h" 13 #include "clang/Driver/Action.h" 14 #include "clang/Driver/Job.h" 15 #include "clang/Driver/Util.h" 16 #include "llvm/ADT/ArrayRef.h" 17 #include "llvm/ADT/DenseMap.h" 18 #include "llvm/ADT/Optional.h" 19 #include "llvm/ADT/StringRef.h" 20 #include "llvm/Option/Option.h" 21 #include <cassert> 22 #include <iterator> 23 #include <map> 24 #include <memory> 25 #include <utility> 26 #include <vector> 27 28 namespace llvm { 29 namespace opt { 30 31 class DerivedArgList; 32 class InputArgList; 33 34 } // namespace opt 35 } // namespace llvm 36 37 namespace clang { 38 namespace driver { 39 40 class Driver; 41 class ToolChain; 42 43 /// Compilation - A set of tasks to perform for a single driver 44 /// invocation. 45 class Compilation { 46 /// The driver we were created by. 47 const Driver &TheDriver; 48 49 /// The default tool chain. 50 const ToolChain &DefaultToolChain; 51 52 /// A mask of all the programming models the host has to support in the 53 /// current compilation. 54 unsigned ActiveOffloadMask = 0; 55 56 /// Array with the toolchains of offloading host and devices in the order they 57 /// were requested by the user. We are preserving that order in case the code 58 /// generation needs to derive a programming-model-specific semantic out of 59 /// it. 60 std::multimap<Action::OffloadKind, const ToolChain *> 61 OrderedOffloadingToolchains; 62 63 /// The original (untranslated) input argument list. 64 llvm::opt::InputArgList *Args; 65 66 /// The driver translated arguments. Note that toolchains may perform their 67 /// own argument translation. 68 llvm::opt::DerivedArgList *TranslatedArgs; 69 70 /// The list of actions we've created via MakeAction. This is not accessible 71 /// to consumers; it's here just to manage ownership. 72 std::vector<std::unique_ptr<Action>> AllActions; 73 74 /// The list of actions. This is maintained and modified by consumers, via 75 /// getActions(). 76 ActionList Actions; 77 78 /// The root list of jobs. 79 JobList Jobs; 80 81 /// Cache of translated arguments for a particular tool chain, bound 82 /// architecture, and device offload kind. 83 struct TCArgsKey final { 84 const ToolChain *TC = nullptr; 85 StringRef BoundArch; 86 Action::OffloadKind DeviceOffloadKind = Action::OFK_None; 87 88 TCArgsKey(const ToolChain *TC, StringRef BoundArch, 89 Action::OffloadKind DeviceOffloadKind) 90 : TC(TC), BoundArch(BoundArch), DeviceOffloadKind(DeviceOffloadKind) {} 91 92 bool operator<(const TCArgsKey &K) const { 93 if (TC < K.TC) 94 return true; 95 else if (TC == K.TC && BoundArch < K.BoundArch) 96 return true; 97 else if (TC == K.TC && BoundArch == K.BoundArch && 98 DeviceOffloadKind < K.DeviceOffloadKind) 99 return true; 100 return false; 101 } 102 }; 103 std::map<TCArgsKey, llvm::opt::DerivedArgList *> TCArgs; 104 105 /// Temporary files which should be removed on exit. 106 llvm::opt::ArgStringList TempFiles; 107 108 /// Result files which should be removed on failure. 109 ArgStringMap ResultFiles; 110 111 /// Result files which are generated correctly on failure, and which should 112 /// only be removed if we crash. 113 ArgStringMap FailureResultFiles; 114 115 /// Optional redirection for stdin, stdout, stderr. 116 std::vector<Optional<StringRef>> Redirects; 117 118 /// Callback called after compilation job has been finished. 119 /// Arguments of the callback are the compilation job as an instance of 120 /// class Command and the exit status of the corresponding child process. 121 std::function<void(const Command &, int)> PostCallback; 122 123 /// Whether we're compiling for diagnostic purposes. 124 bool ForDiagnostics = false; 125 126 /// Whether an error during the parsing of the input args. 127 bool ContainsError; 128 129 /// Whether to keep temporary files regardless of -save-temps. 130 bool ForceKeepTempFiles = false; 131 132 public: 133 Compilation(const Driver &D, const ToolChain &DefaultToolChain, 134 llvm::opt::InputArgList *Args, 135 llvm::opt::DerivedArgList *TranslatedArgs, bool ContainsError); 136 ~Compilation(); 137 138 const Driver &getDriver() const { return TheDriver; } 139 140 const ToolChain &getDefaultToolChain() const { return DefaultToolChain; } 141 142 unsigned isOffloadingHostKind(Action::OffloadKind Kind) const { 143 return ActiveOffloadMask & Kind; 144 } 145 146 /// Iterator that visits device toolchains of a given kind. 147 using const_offload_toolchains_iterator = 148 const std::multimap<Action::OffloadKind, 149 const ToolChain *>::const_iterator; 150 using const_offload_toolchains_range = 151 std::pair<const_offload_toolchains_iterator, 152 const_offload_toolchains_iterator>; 153 154 template <Action::OffloadKind Kind> 155 const_offload_toolchains_range getOffloadToolChains() const { 156 return OrderedOffloadingToolchains.equal_range(Kind); 157 } 158 159 /// Return true if an offloading tool chain of a given kind exists. 160 template <Action::OffloadKind Kind> bool hasOffloadToolChain() const { 161 return OrderedOffloadingToolchains.find(Kind) != 162 OrderedOffloadingToolchains.end(); 163 } 164 165 /// Return an offload toolchain of the provided kind. Only one is expected to 166 /// exist. 167 template <Action::OffloadKind Kind> 168 const ToolChain *getSingleOffloadToolChain() const { 169 auto TCs = getOffloadToolChains<Kind>(); 170 171 assert(TCs.first != TCs.second && 172 "No tool chains of the selected kind exist!"); 173 assert(std::next(TCs.first) == TCs.second && 174 "More than one tool chain of the this kind exist."); 175 return TCs.first->second; 176 } 177 178 void addOffloadDeviceToolChain(const ToolChain *DeviceToolChain, 179 Action::OffloadKind OffloadKind) { 180 assert(OffloadKind != Action::OFK_Host && OffloadKind != Action::OFK_None && 181 "This is not a device tool chain!"); 182 183 // Update the host offload kind to also contain this kind. 184 ActiveOffloadMask |= OffloadKind; 185 OrderedOffloadingToolchains.insert( 186 std::make_pair(OffloadKind, DeviceToolChain)); 187 } 188 189 const llvm::opt::InputArgList &getInputArgs() const { return *Args; } 190 191 const llvm::opt::DerivedArgList &getArgs() const { return *TranslatedArgs; } 192 193 llvm::opt::DerivedArgList &getArgs() { return *TranslatedArgs; } 194 195 ActionList &getActions() { return Actions; } 196 const ActionList &getActions() const { return Actions; } 197 198 /// Creates a new Action owned by this Compilation. 199 /// 200 /// The new Action is *not* added to the list returned by getActions(). 201 template <typename T, typename... Args> T *MakeAction(Args &&... Arg) { 202 T *RawPtr = new T(std::forward<Args>(Arg)...); 203 AllActions.push_back(std::unique_ptr<Action>(RawPtr)); 204 return RawPtr; 205 } 206 207 JobList &getJobs() { return Jobs; } 208 const JobList &getJobs() const { return Jobs; } 209 210 void addCommand(std::unique_ptr<Command> C) { Jobs.addJob(std::move(C)); } 211 212 const llvm::opt::ArgStringList &getTempFiles() const { return TempFiles; } 213 214 const ArgStringMap &getResultFiles() const { return ResultFiles; } 215 216 const ArgStringMap &getFailureResultFiles() const { 217 return FailureResultFiles; 218 } 219 220 /// Installs a handler that is executed when a compilation job is finished. 221 /// The arguments of the callback specify the compilation job as an instance 222 /// of class Command and the exit status of the child process executed that 223 /// job. 224 void setPostCallback(const std::function<void(const Command &, int)> &CB) { 225 PostCallback = CB; 226 } 227 228 /// Returns the sysroot path. 229 StringRef getSysRoot() const; 230 231 /// getArgsForToolChain - Return the derived argument list for the 232 /// tool chain \p TC (or the default tool chain, if TC is not specified). 233 /// If a device offloading kind is specified, a translation specific for that 234 /// kind is performed, if any. 235 /// 236 /// \param BoundArch - The bound architecture name, or 0. 237 /// \param DeviceOffloadKind - The offload device kind that should be used in 238 /// the translation, if any. 239 const llvm::opt::DerivedArgList & 240 getArgsForToolChain(const ToolChain *TC, StringRef BoundArch, 241 Action::OffloadKind DeviceOffloadKind); 242 243 /// addTempFile - Add a file to remove on exit, and returns its 244 /// argument. 245 const char *addTempFile(const char *Name) { 246 TempFiles.push_back(Name); 247 return Name; 248 } 249 250 /// addResultFile - Add a file to remove on failure, and returns its 251 /// argument. 252 const char *addResultFile(const char *Name, const JobAction *JA) { 253 ResultFiles[JA] = Name; 254 return Name; 255 } 256 257 /// addFailureResultFile - Add a file to remove if we crash, and returns its 258 /// argument. 259 const char *addFailureResultFile(const char *Name, const JobAction *JA) { 260 FailureResultFiles[JA] = Name; 261 return Name; 262 } 263 264 /// CleanupFile - Delete a given file. 265 /// 266 /// \param IssueErrors - Report failures as errors. 267 /// \return Whether the file was removed successfully. 268 bool CleanupFile(const char *File, bool IssueErrors = false) const; 269 270 /// CleanupFileList - Remove the files in the given list. 271 /// 272 /// \param IssueErrors - Report failures as errors. 273 /// \return Whether all files were removed successfully. 274 bool CleanupFileList(const llvm::opt::ArgStringList &Files, 275 bool IssueErrors = false) const; 276 277 /// CleanupFileMap - Remove the files in the given map. 278 /// 279 /// \param JA - If specified, only delete the files associated with this 280 /// JobAction. Otherwise, delete all files in the map. 281 /// \param IssueErrors - Report failures as errors. 282 /// \return Whether all files were removed successfully. 283 bool CleanupFileMap(const ArgStringMap &Files, 284 const JobAction *JA, 285 bool IssueErrors = false) const; 286 287 /// ExecuteCommand - Execute an actual command. 288 /// 289 /// \param FailingCommand - For non-zero results, this will be set to the 290 /// Command which failed, if any. 291 /// \return The result code of the subprocess. 292 int ExecuteCommand(const Command &C, const Command *&FailingCommand) const; 293 294 /// ExecuteJob - Execute a single job. 295 /// 296 /// \param FailingCommands - For non-zero results, this will be a vector of 297 /// failing commands and their associated result code. 298 void ExecuteJobs( 299 const JobList &Jobs, 300 SmallVectorImpl<std::pair<int, const Command *>> &FailingCommands) const; 301 302 /// initCompilationForDiagnostics - Remove stale state and suppress output 303 /// so compilation can be reexecuted to generate additional diagnostic 304 /// information (e.g., preprocessed source(s)). 305 void initCompilationForDiagnostics(); 306 307 /// Return true if we're compiling for diagnostics. 308 bool isForDiagnostics() const { return ForDiagnostics; } 309 310 /// Return whether an error during the parsing of the input args. 311 bool containsError() const { return ContainsError; } 312 313 /// Force driver to fail before toolchain is created. This is necessary when 314 /// error happens in action builder. 315 void setContainsError() { ContainsError = true; } 316 317 /// Redirect - Redirect output of this compilation. Can only be done once. 318 /// 319 /// \param Redirects - array of optional paths. The array should have a size 320 /// of three. The inferior process's stdin(0), stdout(1), and stderr(2) will 321 /// be redirected to the corresponding paths, if provided (not llvm::None). 322 void Redirect(ArrayRef<Optional<StringRef>> Redirects); 323 }; 324 325 } // namespace driver 326 } // namespace clang 327 328 #endif // LLVM_CLANG_DRIVER_COMPILATION_H 329