| //===--- Action.h - Abstract compilation steps ------------------*- C++ -*-===// |
| // |
| // The LLVM Compiler Infrastructure |
| // |
| // This file is distributed under the University of Illinois Open Source |
| // License. See LICENSE.TXT for details. |
| // |
| //===----------------------------------------------------------------------===// |
| |
| #ifndef LLVM_CLANG_DRIVER_ACTION_H |
| #define LLVM_CLANG_DRIVER_ACTION_H |
| |
| #include "clang/Driver/Types.h" |
| #include "clang/Driver/Util.h" |
| #include "llvm/ADT/SmallVector.h" |
| |
| namespace llvm { |
| |
| class StringRef; |
| |
| namespace opt { |
| class Arg; |
| } |
| } |
| |
| namespace clang { |
| namespace driver { |
| |
| /// Action - Represent an abstract compilation step to perform. |
| /// |
| /// An action represents an edge in the compilation graph; typically |
| /// it is a job to transform an input using some tool. |
| /// |
| /// The current driver is hard wired to expect actions which produce a |
| /// single primary output, at least in terms of controlling the |
| /// compilation. Actions can produce auxiliary files, but can only |
| /// produce a single output to feed into subsequent actions. |
| /// |
| /// Actions are usually owned by a Compilation, which creates new |
| /// actions via MakeAction(). |
| class Action { |
| public: |
| typedef ActionList::size_type size_type; |
| typedef ActionList::iterator iterator; |
| typedef ActionList::const_iterator const_iterator; |
| |
| enum ActionClass { |
| InputClass = 0, |
| BindArchClass, |
| CudaDeviceClass, |
| CudaHostClass, |
| PreprocessJobClass, |
| PrecompileJobClass, |
| AnalyzeJobClass, |
| MigrateJobClass, |
| CompileJobClass, |
| BackendJobClass, |
| AssembleJobClass, |
| LinkJobClass, |
| LipoJobClass, |
| DsymutilJobClass, |
| VerifyDebugInfoJobClass, |
| VerifyPCHJobClass, |
| |
| JobClassFirst=PreprocessJobClass, |
| JobClassLast=VerifyPCHJobClass |
| }; |
| |
| static const char *getClassName(ActionClass AC); |
| |
| private: |
| ActionClass Kind; |
| |
| /// The output type of this action. |
| types::ID Type; |
| |
| ActionList Inputs; |
| |
| protected: |
| Action(ActionClass Kind, types::ID Type) : Action(Kind, ActionList(), Type) {} |
| Action(ActionClass Kind, Action *Input, types::ID Type) |
| : Action(Kind, ActionList({Input}), Type) {} |
| Action(ActionClass Kind, Action *Input) |
| : Action(Kind, ActionList({Input}), Input->getType()) {} |
| Action(ActionClass Kind, const ActionList &Inputs, types::ID Type) |
| : Kind(Kind), Type(Type), Inputs(Inputs) {} |
| |
| public: |
| virtual ~Action(); |
| |
| const char *getClassName() const { return Action::getClassName(getKind()); } |
| |
| ActionClass getKind() const { return Kind; } |
| types::ID getType() const { return Type; } |
| |
| ActionList &getInputs() { return Inputs; } |
| const ActionList &getInputs() const { return Inputs; } |
| |
| size_type size() const { return Inputs.size(); } |
| |
| iterator begin() { return Inputs.begin(); } |
| iterator end() { return Inputs.end(); } |
| const_iterator begin() const { return Inputs.begin(); } |
| const_iterator end() const { return Inputs.end(); } |
| }; |
| |
| class InputAction : public Action { |
| virtual void anchor(); |
| const llvm::opt::Arg &Input; |
| |
| public: |
| InputAction(const llvm::opt::Arg &Input, types::ID Type); |
| |
| const llvm::opt::Arg &getInputArg() const { return Input; } |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == InputClass; |
| } |
| }; |
| |
| class BindArchAction : public Action { |
| virtual void anchor(); |
| /// The architecture to bind, or 0 if the default architecture |
| /// should be bound. |
| const char *ArchName; |
| |
| public: |
| BindArchAction(Action *Input, const char *ArchName); |
| |
| const char *getArchName() const { return ArchName; } |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == BindArchClass; |
| } |
| }; |
| |
| class CudaDeviceAction : public Action { |
| virtual void anchor(); |
| /// GPU architecture to bind. Always of the form /sm_\d+/ or null (when the |
| /// action applies to multiple architectures). |
| const char *GpuArchName; |
| /// True when action results are not consumed by the host action (e.g when |
| /// -fsyntax-only or --cuda-device-only options are used). |
| bool AtTopLevel; |
| |
| public: |
| CudaDeviceAction(Action *Input, const char *ArchName, bool AtTopLevel); |
| |
| const char *getGpuArchName() const { return GpuArchName; } |
| |
| /// Gets the compute_XX that corresponds to getGpuArchName(). Returns null |
| /// when getGpuArchName() is null. |
| const char *getComputeArchName() const; |
| |
| bool isAtTopLevel() const { return AtTopLevel; } |
| |
| static bool IsValidGpuArchName(llvm::StringRef ArchName); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == CudaDeviceClass; |
| } |
| }; |
| |
| class CudaHostAction : public Action { |
| virtual void anchor(); |
| ActionList DeviceActions; |
| |
| public: |
| CudaHostAction(Action *Input, const ActionList &DeviceActions); |
| |
| const ActionList &getDeviceActions() const { return DeviceActions; } |
| |
| static bool classof(const Action *A) { return A->getKind() == CudaHostClass; } |
| }; |
| |
| class JobAction : public Action { |
| virtual void anchor(); |
| protected: |
| JobAction(ActionClass Kind, Action *Input, types::ID Type); |
| JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type); |
| |
| public: |
| static bool classof(const Action *A) { |
| return (A->getKind() >= JobClassFirst && |
| A->getKind() <= JobClassLast); |
| } |
| }; |
| |
| class PreprocessJobAction : public JobAction { |
| void anchor() override; |
| public: |
| PreprocessJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == PreprocessJobClass; |
| } |
| }; |
| |
| class PrecompileJobAction : public JobAction { |
| void anchor() override; |
| public: |
| PrecompileJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == PrecompileJobClass; |
| } |
| }; |
| |
| class AnalyzeJobAction : public JobAction { |
| void anchor() override; |
| public: |
| AnalyzeJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == AnalyzeJobClass; |
| } |
| }; |
| |
| class MigrateJobAction : public JobAction { |
| void anchor() override; |
| public: |
| MigrateJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == MigrateJobClass; |
| } |
| }; |
| |
| class CompileJobAction : public JobAction { |
| void anchor() override; |
| public: |
| CompileJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == CompileJobClass; |
| } |
| }; |
| |
| class BackendJobAction : public JobAction { |
| void anchor() override; |
| public: |
| BackendJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == BackendJobClass; |
| } |
| }; |
| |
| class AssembleJobAction : public JobAction { |
| void anchor() override; |
| public: |
| AssembleJobAction(Action *Input, types::ID OutputType); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == AssembleJobClass; |
| } |
| }; |
| |
| class LinkJobAction : public JobAction { |
| void anchor() override; |
| public: |
| LinkJobAction(ActionList &Inputs, types::ID Type); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == LinkJobClass; |
| } |
| }; |
| |
| class LipoJobAction : public JobAction { |
| void anchor() override; |
| public: |
| LipoJobAction(ActionList &Inputs, types::ID Type); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == LipoJobClass; |
| } |
| }; |
| |
| class DsymutilJobAction : public JobAction { |
| void anchor() override; |
| public: |
| DsymutilJobAction(ActionList &Inputs, types::ID Type); |
| |
| static bool classof(const Action *A) { |
| return A->getKind() == DsymutilJobClass; |
| } |
| }; |
| |
| class VerifyJobAction : public JobAction { |
| void anchor() override; |
| public: |
| VerifyJobAction(ActionClass Kind, Action *Input, types::ID Type); |
| static bool classof(const Action *A) { |
| return A->getKind() == VerifyDebugInfoJobClass || |
| A->getKind() == VerifyPCHJobClass; |
| } |
| }; |
| |
| class VerifyDebugInfoJobAction : public VerifyJobAction { |
| void anchor() override; |
| public: |
| VerifyDebugInfoJobAction(Action *Input, types::ID Type); |
| static bool classof(const Action *A) { |
| return A->getKind() == VerifyDebugInfoJobClass; |
| } |
| }; |
| |
| class VerifyPCHJobAction : public VerifyJobAction { |
| void anchor() override; |
| public: |
| VerifyPCHJobAction(Action *Input, types::ID Type); |
| static bool classof(const Action *A) { |
| return A->getKind() == VerifyPCHJobClass; |
| } |
| }; |
| |
| } // end namespace driver |
| } // end namespace clang |
| |
| #endif |