Home | History | Annotate | Download | only in Driver 
      1 //===--- Action.cpp - Abstract compilation steps --------------------------===//
      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/Action.h"
     11 #include "llvm/Support/ErrorHandling.h"
     12 #include <cassert>
     13 using namespace clang::driver;
     14 using namespace llvm::opt;
     15 
     16 Action::~Action() {
     17   if (OwnsInputs) {
     18     for (iterator it = begin(), ie = end(); it != ie; ++it)
     19       delete *it;
     20   }
     21 }
     22 
     23 const char *Action::getClassName(ActionClass AC) {
     24   switch (AC) {
     25   case InputClass: return "input";
     26   case BindArchClass: return "bind-arch";
     27   case CudaDeviceClass: return "cuda-device";
     28   case CudaHostClass: return "cuda-host";
     29   case PreprocessJobClass: return "preprocessor";
     30   case PrecompileJobClass: return "precompiler";
     31   case AnalyzeJobClass: return "analyzer";
     32   case MigrateJobClass: return "migrator";
     33   case CompileJobClass: return "compiler";
     34   case BackendJobClass: return "backend";
     35   case AssembleJobClass: return "assembler";
     36   case LinkJobClass: return "linker";
     37   case LipoJobClass: return "lipo";
     38   case DsymutilJobClass: return "dsymutil";
     39   case VerifyDebugInfoJobClass: return "verify-debug-info";
     40   case VerifyPCHJobClass: return "verify-pch";
     41   }
     42 
     43   llvm_unreachable("invalid class");
     44 }
     45 
     46 void InputAction::anchor() {}
     47 
     48 InputAction::InputAction(const Arg &_Input, types::ID _Type)
     49   : Action(InputClass, _Type), Input(_Input) {
     50 }
     51 
     52 void BindArchAction::anchor() {}
     53 
     54 BindArchAction::BindArchAction(std::unique_ptr<Action> Input,
     55                                const char *_ArchName)
     56     : Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}
     57 
     58 void CudaDeviceAction::anchor() {}
     59 
     60 CudaDeviceAction::CudaDeviceAction(std::unique_ptr<Action> Input,
     61                                    const char *ArchName, bool AtTopLevel)
     62     : Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
     63       AtTopLevel(AtTopLevel) {}
     64 
     65 void CudaHostAction::anchor() {}
     66 
     67 CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,
     68                                const ActionList &DeviceActions)
     69     : Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}
     70 
     71 CudaHostAction::~CudaHostAction() {
     72   for (auto &DA : DeviceActions)
     73     delete DA;
     74 }
     75 
     76 void JobAction::anchor() {}
     77 
     78 JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,
     79                      types::ID Type)
     80     : Action(Kind, std::move(Input), Type) {}
     81 
     82 JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
     83   : Action(Kind, Inputs, Type) {
     84 }
     85 
     86 void PreprocessJobAction::anchor() {}
     87 
     88 PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,
     89                                          types::ID OutputType)
     90     : JobAction(PreprocessJobClass, std::move(Input), OutputType) {}
     91 
     92 void PrecompileJobAction::anchor() {}
     93 
     94 PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,
     95                                          types::ID OutputType)
     96     : JobAction(PrecompileJobClass, std::move(Input), OutputType) {}
     97 
     98 void AnalyzeJobAction::anchor() {}
     99 
    100 AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,
    101                                    types::ID OutputType)
    102     : JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}
    103 
    104 void MigrateJobAction::anchor() {}
    105 
    106 MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,
    107                                    types::ID OutputType)
    108     : JobAction(MigrateJobClass, std::move(Input), OutputType) {}
    109 
    110 void CompileJobAction::anchor() {}
    111 
    112 CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,
    113                                    types::ID OutputType)
    114     : JobAction(CompileJobClass, std::move(Input), OutputType) {}
    115 
    116 void BackendJobAction::anchor() {}
    117 
    118 BackendJobAction::BackendJobAction(std::unique_ptr<Action> Input,
    119                                    types::ID OutputType)
    120     : JobAction(BackendJobClass, std::move(Input), OutputType) {}
    121 
    122 void AssembleJobAction::anchor() {}
    123 
    124 AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,
    125                                      types::ID OutputType)
    126     : JobAction(AssembleJobClass, std::move(Input), OutputType) {}
    127 
    128 void LinkJobAction::anchor() {}
    129 
    130 LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
    131   : JobAction(LinkJobClass, Inputs, Type) {
    132 }
    133 
    134 void LipoJobAction::anchor() {}
    135 
    136 LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
    137   : JobAction(LipoJobClass, Inputs, Type) {
    138 }
    139 
    140 void DsymutilJobAction::anchor() {}
    141 
    142 DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
    143   : JobAction(DsymutilJobClass, Inputs, Type) {
    144 }
    145 
    146 void VerifyJobAction::anchor() {}
    147 
    148 VerifyJobAction::VerifyJobAction(ActionClass Kind,
    149                                  std::unique_ptr<Action> Input, types::ID Type)
    150     : JobAction(Kind, std::move(Input), Type) {
    151   assert((Kind == VerifyDebugInfoJobClass || Kind == VerifyPCHJobClass) &&
    152          "ActionClass is not a valid VerifyJobAction");
    153 }
    154 
    155 void VerifyDebugInfoJobAction::anchor() {}
    156 
    157 VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
    158     std::unique_ptr<Action> Input, types::ID Type)
    159     : VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}
    160 
    161 void VerifyPCHJobAction::anchor() {}
    162 
    163 VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,
    164                                        types::ID Type)
    165     : VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}
    166