clang 8.0.0

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