Coverage Report

Created: 2017-10-03 07:32

/Users/buildslave/jenkins/sharedspace/clang-stage2-coverage-R@2/llvm/tools/clang/include/clang/Driver/Action.h
Line
Count
Source (jump to first uncovered line)
1
//===--- Action.h - Abstract compilation steps ------------------*- 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_ACTION_H
11
#define LLVM_CLANG_DRIVER_ACTION_H
12
13
#include "clang/Basic/Cuda.h"
14
#include "clang/Driver/Types.h"
15
#include "clang/Driver/Util.h"
16
#include "llvm/ADT/STLExtras.h"
17
#include "llvm/ADT/SmallVector.h"
18
19
namespace llvm {
20
21
class StringRef;
22
23
namespace opt {
24
  class Arg;
25
}
26
}
27
28
namespace clang {
29
namespace driver {
30
31
class ToolChain;
32
33
/// Action - Represent an abstract compilation step to perform.
34
///
35
/// An action represents an edge in the compilation graph; typically
36
/// it is a job to transform an input using some tool.
37
///
38
/// The current driver is hard wired to expect actions which produce a
39
/// single primary output, at least in terms of controlling the
40
/// compilation. Actions can produce auxiliary files, but can only
41
/// produce a single output to feed into subsequent actions.
42
///
43
/// Actions are usually owned by a Compilation, which creates new
44
/// actions via MakeAction().
45
class Action {
46
public:
47
  typedef ActionList::size_type size_type;
48
  typedef ActionList::iterator input_iterator;
49
  typedef ActionList::const_iterator input_const_iterator;
50
  typedef llvm::iterator_range<input_iterator> input_range;
51
  typedef llvm::iterator_range<input_const_iterator> input_const_range;
52
53
  enum ActionClass {
54
    InputClass = 0,
55
    BindArchClass,
56
    OffloadClass,
57
    PreprocessJobClass,
58
    PrecompileJobClass,
59
    AnalyzeJobClass,
60
    MigrateJobClass,
61
    CompileJobClass,
62
    BackendJobClass,
63
    AssembleJobClass,
64
    LinkJobClass,
65
    LipoJobClass,
66
    DsymutilJobClass,
67
    VerifyDebugInfoJobClass,
68
    VerifyPCHJobClass,
69
    OffloadBundlingJobClass,
70
    OffloadUnbundlingJobClass,
71
72
    JobClassFirst = PreprocessJobClass,
73
    JobClassLast = OffloadUnbundlingJobClass
74
  };
75
76
  // The offloading kind determines if this action is binded to a particular
77
  // programming model. Each entry reserves one bit. We also have a special kind
78
  // to designate the host offloading tool chain.
79
  enum OffloadKind {
80
    OFK_None = 0x00,
81
    // The host offloading tool chain.
82
    OFK_Host = 0x01,
83
    // The device offloading tool chains - one bit for each programming model.
84
    OFK_Cuda = 0x02,
85
    OFK_OpenMP = 0x04,
86
  };
87
88
  static const char *getClassName(ActionClass AC);
89
90
private:
91
  ActionClass Kind;
92
93
  /// The output type of this action.
94
  types::ID Type;
95
96
  ActionList Inputs;
97
98
  /// Flag that is set to true if this action can be collapsed with others
99
  /// actions that depend on it. This is true by default and set to false when
100
  /// the action is used by two different tool chains, which is enabled by the
101
  /// offloading support implementation.
102
  bool CanBeCollapsedWithNextDependentAction = true;
103
104
protected:
105
  ///
106
  /// Offload information.
107
  ///
108
109
  /// The host offloading kind - a combination of kinds encoded in a mask.
110
  /// Multiple programming models may be supported simultaneously by the same
111
  /// host.
112
  unsigned ActiveOffloadKindMask = 0u;
113
  /// Offloading kind of the device.
114
  OffloadKind OffloadingDeviceKind = OFK_None;
115
  /// The Offloading architecture associated with this action.
116
  const char *OffloadingArch = nullptr;
117
118
56.6k
  Action(ActionClass Kind, types::ID Type) : Action(Kind, ActionList(), Type) {}
119
  Action(ActionClass Kind, Action *Input, types::ID Type)
120
87.7k
      : Action(Kind, ActionList({Input}), Type) {}
121
  Action(ActionClass Kind, Action *Input)
122
25.3k
      : Action(Kind, ActionList({Input}), Input->getType()) {}
123
  Action(ActionClass Kind, const ActionList &Inputs, types::ID Type)
124
176k
      : Kind(Kind), Type(Type), Inputs(Inputs) {}
125
126
public:
127
  virtual ~Action();
128
129
0
  const char *getClassName() const { return Action::getClassName(getKind()); }
130
131
1.45M
  ActionClass getKind() const { return Kind; }
132
437k
  types::ID getType() const { return Type; }
133
134
1.10k
  ActionList &getInputs() { return Inputs; }
135
201k
  const ActionList &getInputs() const { return Inputs; }
136
137
35.8k
  size_type size() const { return Inputs.size(); }
138
139
24
  input_iterator input_begin() { return Inputs.begin(); }
140
0
  input_iterator input_end() { return Inputs.end(); }
141
0
  input_range inputs() { return input_range(input_begin(), input_end()); }
142
65.0k
  input_const_iterator input_begin() const { return Inputs.begin(); }
143
8.38k
  input_const_iterator input_end() const { return Inputs.end(); }
144
8.38k
  input_const_range inputs() const {
145
8.38k
    return input_const_range(input_begin(), input_end());
146
8.38k
  }
147
148
  /// Mark this action as not legal to collapse.
149
35
  void setCannotBeCollapsedWithNextDependentAction() {
150
35
    CanBeCollapsedWithNextDependentAction = false;
151
35
  }
152
  /// Return true if this function can be collapsed with others.
153
131k
  bool isCollapsingWithNextDependentActionLegal() const {
154
131k
    return CanBeCollapsedWithNextDependentAction;
155
131k
  }
156
157
  /// Return a string containing the offload kind of the action.
158
  std::string getOffloadingKindPrefix() const;
159
  /// Return a string that can be used as prefix in order to generate unique
160
  /// files for each offloading kind. By default, no prefix is used for
161
  /// non-device kinds, except if \a CreatePrefixForHost is set.
162
  static std::string
163
  GetOffloadingFileNamePrefix(OffloadKind Kind,
164
                              llvm::StringRef NormalizedTriple,
165
                              bool CreatePrefixForHost = false);
166
  /// Return a string containing a offload kind name.
167
  static StringRef GetOffloadKindName(OffloadKind Kind);
168
169
  /// Set the device offload info of this action and propagate it to its
170
  /// dependences.
171
  void propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch);
172
  /// Append the host offload info of this action and propagate it to its
173
  /// dependences.
174
  void propagateHostOffloadInfo(unsigned OKinds, const char *OArch);
175
  /// Set the offload info of this action to be the same as the provided action,
176
  /// and propagate it to its dependences.
177
  void propagateOffloadInfo(const Action *A);
178
179
32.1k
  unsigned getOffloadingHostActiveKinds() const {
180
32.1k
    return ActiveOffloadKindMask;
181
32.1k
  }
182
229k
  OffloadKind getOffloadingDeviceKind() const { return OffloadingDeviceKind; }
183
1.08k
  const char *getOffloadingArch() const { return OffloadingArch; }
184
185
  /// Check if this action have any offload kinds. Note that host offload kinds
186
  /// are only set if the action is a dependence to a host offload action.
187
133k
  bool isHostOffloading(OffloadKind OKind) const {
188
133k
    return ActiveOffloadKindMask & OKind;
189
133k
  }
190
124k
  bool isDeviceOffloading(OffloadKind OKind) const {
191
124k
    return OffloadingDeviceKind == OKind;
192
124k
  }
193
46.8k
  bool isOffloading(OffloadKind OKind) const {
194
46.6k
    return isHostOffloading(OKind) || isDeviceOffloading(OKind);
195
46.8k
  }
196
};
197
198
class InputAction : public Action {
199
  virtual void anchor();
200
  const llvm::opt::Arg &Input;
201
202
public:
203
  InputAction(const llvm::opt::Arg &Input, types::ID Type);
204
205
57.5k
  const llvm::opt::Arg &getInputArg() const { return Input; }
206
207
119k
  static bool classof(const Action *A) {
208
119k
    return A->getKind() == InputClass;
209
119k
  }
210
};
211
212
class BindArchAction : public Action {
213
  virtual void anchor();
214
  /// The architecture to bind, or 0 if the default architecture
215
  /// should be bound.
216
  StringRef ArchName;
217
218
public:
219
  BindArchAction(Action *Input, StringRef ArchName);
220
221
25.1k
  StringRef getArchName() const { return ArchName; }
222
223
61.3k
  static bool classof(const Action *A) {
224
61.3k
    return A->getKind() == BindArchClass;
225
61.3k
  }
226
};
227
228
/// An offload action combines host or/and device actions according to the
229
/// programming model implementation needs and propagates the offloading kind to
230
/// its dependences.
231
class OffloadAction final : public Action {
232
  virtual void anchor();
233
234
public:
235
  /// Type used to communicate device actions. It associates bound architecture,
236
  /// toolchain, and offload kind to each action.
237
  class DeviceDependences final {
238
  public:
239
    typedef SmallVector<const ToolChain *, 3> ToolChainList;
240
    typedef SmallVector<const char *, 3> BoundArchList;
241
    typedef SmallVector<OffloadKind, 3> OffloadKindList;
242
243
  private:
244
    // Lists that keep the information for each dependency. All the lists are
245
    // meant to be updated in sync. We are adopting separate lists instead of a
246
    // list of structs, because that simplifies forwarding the actions list to
247
    // initialize the inputs of the base Action class.
248
249
    /// The dependence actions.
250
    ActionList DeviceActions;
251
    /// The offloading toolchains that should be used with the action.
252
    ToolChainList DeviceToolChains;
253
    /// The architectures that should be used with this action.
254
    BoundArchList DeviceBoundArchs;
255
    /// The offload kind of each dependence.
256
    OffloadKindList DeviceOffloadKinds;
257
258
  public:
259
    /// Add a action along with the associated toolchain, bound arch, and
260
    /// offload kind.
261
    void add(Action &A, const ToolChain &TC, const char *BoundArch,
262
             OffloadKind OKind);
263
264
    /// Get each of the individual arrays.
265
125k
    const ActionList &getActions() const { return DeviceActions; };
266
448
    const ToolChainList &getToolChains() const { return DeviceToolChains; };
267
461
    const BoundArchList &getBoundArchs() const { return DeviceBoundArchs; };
268
555
    const OffloadKindList &getOffloadKinds() const {
269
555
      return DeviceOffloadKinds;
270
555
    };
271
  };
272
273
  /// Type used to communicate host actions. It associates bound architecture,
274
  /// toolchain, and offload kinds to the host action.
275
  class HostDependence final {
276
    /// The dependence action.
277
    Action &HostAction;
278
    /// The offloading toolchain that should be used with the action.
279
    const ToolChain &HostToolChain;
280
    /// The architectures that should be used with this action.
281
    const char *HostBoundArch = nullptr;
282
    /// The offload kind of each dependence.
283
    unsigned HostOffloadKinds = 0u;
284
285
  public:
286
    HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
287
                   const unsigned OffloadKinds)
288
        : HostAction(A), HostToolChain(TC), HostBoundArch(BoundArch),
289
66
          HostOffloadKinds(OffloadKinds){};
290
    /// Constructor version that obtains the offload kinds from the device
291
    /// dependencies.
292
    HostDependence(Action &A, const ToolChain &TC, const char *BoundArch,
293
                   const DeviceDependences &DDeps);
294
356
    Action *getAction() const { return &HostAction; };
295
178
    const ToolChain *getToolChain() const { return &HostToolChain; };
296
356
    const char *getBoundArch() const { return HostBoundArch; };
297
356
    unsigned getOffloadKinds() const { return HostOffloadKinds; };
298
  };
299
300
  typedef llvm::function_ref<void(Action *, const ToolChain *, const char *)>
301
      OffloadActionWorkTy;
302
303
private:
304
  /// The host offloading toolchain that should be used with the action.
305
  const ToolChain *HostTC = nullptr;
306
307
  /// The tool chains associated with the list of actions.
308
  DeviceDependences::ToolChainList DevToolChains;
309
310
public:
311
  OffloadAction(const HostDependence &HDep);
312
  OffloadAction(const DeviceDependences &DDeps, types::ID Ty);
313
  OffloadAction(const HostDependence &HDep, const DeviceDependences &DDeps);
314
315
  /// Execute the work specified in \a Work on the host dependence.
316
  void doOnHostDependence(const OffloadActionWorkTy &Work) const;
317
318
  /// Execute the work specified in \a Work on each device dependence.
319
  void doOnEachDeviceDependence(const OffloadActionWorkTy &Work) const;
320
321
  /// Execute the work specified in \a Work on each dependence.
322
  void doOnEachDependence(const OffloadActionWorkTy &Work) const;
323
324
  /// Execute the work specified in \a Work on each host or device dependence if
325
  /// \a IsHostDependenceto is true or false, respectively.
326
  void doOnEachDependence(bool IsHostDependence,
327
                          const OffloadActionWorkTy &Work) const;
328
329
  /// Return true if the action has a host dependence.
330
  bool hasHostDependence() const;
331
332
  /// Return the host dependence of this action. This function is only expected
333
  /// to be called if the host dependence exists.
334
  Action *getHostDependence() const;
335
336
  /// Return true if the action has a single device dependence. If \a
337
  /// DoNotConsiderHostActions is set, ignore the host dependence, if any, while
338
  /// accounting for the number of dependences.
339
  bool hasSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
340
341
  /// Return the single device dependence of this action. This function is only
342
  /// expected to be called if a single device dependence exists. If \a
343
  /// DoNotConsiderHostActions is set, a host dependence is allowed.
344
  Action *
345
  getSingleDeviceDependence(bool DoNotConsiderHostActions = false) const;
346
347
250k
  static bool classof(const Action *A) { return A->getKind() == OffloadClass; }
348
};
349
350
class JobAction : public Action {
351
  virtual void anchor();
352
protected:
353
  JobAction(ActionClass Kind, Action *Input, types::ID Type);
354
  JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type);
355
356
public:
357
131k
  static bool classof(const Action *A) {
358
131k
    return (A->getKind() >= JobClassFirst &&
359
90.0k
            A->getKind() <= JobClassLast);
360
131k
  }
361
};
362
363
class PreprocessJobAction : public JobAction {
364
  void anchor() override;
365
public:
366
  PreprocessJobAction(Action *Input, types::ID OutputType);
367
368
104k
  static bool classof(const Action *A) {
369
104k
    return A->getKind() == PreprocessJobClass;
370
104k
  }
371
};
372
373
class PrecompileJobAction : public JobAction {
374
  void anchor() override;
375
public:
376
  PrecompileJobAction(Action *Input, types::ID OutputType);
377
378
60.0k
  static bool classof(const Action *A) {
379
60.0k
    return A->getKind() == PrecompileJobClass;
380
60.0k
  }
381
};
382
383
class AnalyzeJobAction : public JobAction {
384
  void anchor() override;
385
public:
386
  AnalyzeJobAction(Action *Input, types::ID OutputType);
387
388
55.1k
  static bool classof(const Action *A) {
389
55.1k
    return A->getKind() == AnalyzeJobClass;
390
55.1k
  }
391
};
392
393
class MigrateJobAction : public JobAction {
394
  void anchor() override;
395
public:
396
  MigrateJobAction(Action *Input, types::ID OutputType);
397
398
27.5k
  static bool classof(const Action *A) {
399
27.5k
    return A->getKind() == MigrateJobClass;
400
27.5k
  }
401
};
402
403
class CompileJobAction : public JobAction {
404
  void anchor() override;
405
public:
406
  CompileJobAction(Action *Input, types::ID OutputType);
407
408
98.3k
  static bool classof(const Action *A) {
409
98.3k
    return A->getKind() == CompileJobClass;
410
98.3k
  }
411
};
412
413
class BackendJobAction : public JobAction {
414
  void anchor() override;
415
public:
416
  BackendJobAction(Action *Input, types::ID OutputType);
417
418
51.7k
  static bool classof(const Action *A) {
419
51.7k
    return A->getKind() == BackendJobClass;
420
51.7k
  }
421
};
422
423
class AssembleJobAction : public JobAction {
424
  void anchor() override;
425
public:
426
  AssembleJobAction(Action *Input, types::ID OutputType);
427
428
58.5k
  static bool classof(const Action *A) {
429
58.5k
    return A->getKind() == AssembleJobClass;
430
58.5k
  }
431
};
432
433
class LinkJobAction : public JobAction {
434
  void anchor() override;
435
public:
436
  LinkJobAction(ActionList &Inputs, types::ID Type);
437
438
251
  static bool classof(const Action *A) {
439
251
    return A->getKind() == LinkJobClass;
440
251
  }
441
};
442
443
class LipoJobAction : public JobAction {
444
  void anchor() override;
445
public:
446
  LipoJobAction(ActionList &Inputs, types::ID Type);
447
448
30.8k
  static bool classof(const Action *A) {
449
30.8k
    return A->getKind() == LipoJobClass;
450
30.8k
  }
451
};
452
453
class DsymutilJobAction : public JobAction {
454
  void anchor() override;
455
public:
456
  DsymutilJobAction(ActionList &Inputs, types::ID Type);
457
458
88.4k
  static bool classof(const Action *A) {
459
88.4k
    return A->getKind() == DsymutilJobClass;
460
88.4k
  }
461
};
462
463
class VerifyJobAction : public JobAction {
464
  void anchor() override;
465
public:
466
  VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type);
467
88.3k
  static bool classof(const Action *A) {
468
88.3k
    return A->getKind() == VerifyDebugInfoJobClass ||
469
88.3k
           A->getKind() == VerifyPCHJobClass;
470
88.3k
  }
471
};
472
473
class VerifyDebugInfoJobAction : public VerifyJobAction {
474
  void anchor() override;
475
public:
476
  VerifyDebugInfoJobAction(Action *Input, types::ID Type);
477
0
  static bool classof(const Action *A) {
478
0
    return A->getKind() == VerifyDebugInfoJobClass;
479
0
  }
480
};
481
482
class VerifyPCHJobAction : public VerifyJobAction {
483
  void anchor() override;
484
public:
485
  VerifyPCHJobAction(Action *Input, types::ID Type);
486
5.21k
  static bool classof(const Action *A) {
487
5.21k
    return A->getKind() == VerifyPCHJobClass;
488
5.21k
  }
489
};
490
491
class OffloadBundlingJobAction : public JobAction {
492
  void anchor() override;
493
494
public:
495
  // Offloading bundling doesn't change the type of output.
496
  OffloadBundlingJobAction(ActionList &Inputs);
497
498
0
  static bool classof(const Action *A) {
499
0
    return A->getKind() == OffloadBundlingJobClass;
500
0
  }
501
};
502
503
class OffloadUnbundlingJobAction final : public JobAction {
504
  void anchor() override;
505
506
public:
507
  /// Type that provides information about the actions that depend on this
508
  /// unbundling action.
509
  struct DependentActionInfo final {
510
    /// \brief The tool chain of the dependent action.
511
    const ToolChain *DependentToolChain = nullptr;
512
    /// \brief The bound architecture of the dependent action.
513
    StringRef DependentBoundArch;
514
    /// \brief The offload kind of the dependent action.
515
    const OffloadKind DependentOffloadKind = OFK_None;
516
    DependentActionInfo(const ToolChain *DependentToolChain,
517
                        StringRef DependentBoundArch,
518
                        const OffloadKind DependentOffloadKind)
519
        : DependentToolChain(DependentToolChain),
520
          DependentBoundArch(DependentBoundArch),
521
32
          DependentOffloadKind(DependentOffloadKind){};
522
  };
523
524
private:
525
  /// Container that keeps information about each dependence of this unbundling
526
  /// action.
527
  SmallVector<DependentActionInfo, 6> DependentActionInfoArray;
528
529
public:
530
  // Offloading unbundling doesn't change the type of output.
531
  OffloadUnbundlingJobAction(Action *Input);
532
533
  /// Register information about a dependent action.
534
  void registerDependentActionInfo(const ToolChain *TC, StringRef BoundArch,
535
32
                                   OffloadKind Kind) {
536
32
    DependentActionInfoArray.push_back({TC, BoundArch, Kind});
537
32
  }
538
539
  /// Return the information about all depending actions.
540
28
  ArrayRef<DependentActionInfo> getDependentActionsInfo() const {
541
28
    return DependentActionInfoArray;
542
28
  }
543
544
36.0k
  static bool classof(const Action *A) {
545
36.0k
    return A->getKind() == OffloadUnbundlingJobClass;
546
36.0k
  }
547
};
548
549
} // end namespace driver
550
} // end namespace clang
551
552
#endif