llvm/clang/lib/Driver/Action.cpp

//===- Action.cpp - Abstract compilation steps ----------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "clang/Driver/Action.h"
#include "llvm/Support/ErrorHandling.h"
#include <cassert>
#include <string>

usingnamespaceclang;
usingnamespacedriver;
usingnamespacellvm::opt;

Action::~Action() = default;

const char *Action::getClassName(ActionClass AC) { … }

void Action::propagateDeviceOffloadInfo(OffloadKind OKind, const char *OArch,
                                        const ToolChain *OToolChain) { … }

void Action::propagateHostOffloadInfo(unsigned OKinds, const char *OArch) { … }

void Action::propagateOffloadInfo(const Action *A) { … }

std::string Action::getOffloadingKindPrefix() const { … }

/// Return a string that can be used as prefix in order to generate unique files
/// for each offloading kind.
std::string
Action::GetOffloadingFileNamePrefix(OffloadKind Kind,
                                    StringRef NormalizedTriple,
                                    bool CreatePrefixForHost) { … }

/// Return a string with the offload kind name. If that is not defined, we
/// assume 'host'.
StringRef Action::GetOffloadKindName(OffloadKind Kind) { … }

void InputAction::anchor() { … }

InputAction::InputAction(const Arg &_Input, types::ID _Type, StringRef _Id)
    : … { … }

void BindArchAction::anchor() { … }

BindArchAction::BindArchAction(Action *Input, StringRef ArchName)
    : … { … }

void OffloadAction::anchor() { … }

OffloadAction::OffloadAction(const HostDependence &HDep)
    : … { … }

OffloadAction::OffloadAction(const DeviceDependences &DDeps, types::ID Ty)
    : … { … }

OffloadAction::OffloadAction(const HostDependence &HDep,
                             const DeviceDependences &DDeps)
    : … { … }

void OffloadAction::doOnHostDependence(const OffloadActionWorkTy &Work) const { … }

void OffloadAction::doOnEachDeviceDependence(
    const OffloadActionWorkTy &Work) const { … }

void OffloadAction::doOnEachDependence(const OffloadActionWorkTy &Work) const { … }

void OffloadAction::doOnEachDependence(bool IsHostDependence,
                                       const OffloadActionWorkTy &Work) const { … }

bool OffloadAction::hasHostDependence() const { … }

Action *OffloadAction::getHostDependence() const { … }

bool OffloadAction::hasSingleDeviceDependence(
    bool DoNotConsiderHostActions) const { … }

Action *
OffloadAction::getSingleDeviceDependence(bool DoNotConsiderHostActions) const { … }

void OffloadAction::DeviceDependences::add(Action &A, const ToolChain &TC,
                                           const char *BoundArch,
                                           OffloadKind OKind) { … }

void OffloadAction::DeviceDependences::add(Action &A, const ToolChain &TC,
                                           const char *BoundArch,
                                           unsigned OffloadKindMask) { … }

OffloadAction::HostDependence::HostDependence(Action &A, const ToolChain &TC,
                                              const char *BoundArch,
                                              const DeviceDependences &DDeps)
    : … { … }

void JobAction::anchor() { … }

JobAction::JobAction(ActionClass Kind, Action *Input, types::ID Type)
    : … { … }

JobAction::JobAction(ActionClass Kind, const ActionList &Inputs, types::ID Type)
    : … { … }

void PreprocessJobAction::anchor() { … }

PreprocessJobAction::PreprocessJobAction(Action *Input, types::ID OutputType)
    : … { … }

void PrecompileJobAction::anchor() { … }

PrecompileJobAction::PrecompileJobAction(Action *Input, types::ID OutputType)
    : … { … }

PrecompileJobAction::PrecompileJobAction(ActionClass Kind, Action *Input,
                                         types::ID OutputType)
    : … { … }

void ExtractAPIJobAction::anchor() { … }

ExtractAPIJobAction::ExtractAPIJobAction(Action *Inputs, types::ID OutputType)
    : … { … }

void AnalyzeJobAction::anchor() { … }

AnalyzeJobAction::AnalyzeJobAction(Action *Input, types::ID OutputType)
    : … { … }

void MigrateJobAction::anchor() { … }

MigrateJobAction::MigrateJobAction(Action *Input, types::ID OutputType)
    : … { … }

void CompileJobAction::anchor() { … }

CompileJobAction::CompileJobAction(Action *Input, types::ID OutputType)
    : … { … }

void BackendJobAction::anchor() { … }

BackendJobAction::BackendJobAction(Action *Input, types::ID OutputType)
    : … { … }

void AssembleJobAction::anchor() { … }

AssembleJobAction::AssembleJobAction(Action *Input, types::ID OutputType)
    : … { … }

void IfsMergeJobAction::anchor() { … }

IfsMergeJobAction::IfsMergeJobAction(ActionList &Inputs, types::ID Type)
    : … { … }

void LinkJobAction::anchor() { … }

LinkJobAction::LinkJobAction(ActionList &Inputs, types::ID Type)
    : … { … }

void LipoJobAction::anchor() { … }

LipoJobAction::LipoJobAction(ActionList &Inputs, types::ID Type)
    : … { … }

void DsymutilJobAction::anchor() { … }

DsymutilJobAction::DsymutilJobAction(ActionList &Inputs, types::ID Type)
    : … { … }

void VerifyJobAction::anchor() { … }

VerifyJobAction::VerifyJobAction(ActionClass Kind, Action *Input,
                                 types::ID Type)
    : … { … }

void VerifyDebugInfoJobAction::anchor() { … }

VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(Action *Input,
                                                   types::ID Type)
    : … { … }

void VerifyPCHJobAction::anchor() { … }

VerifyPCHJobAction::VerifyPCHJobAction(Action *Input, types::ID Type)
    : … { … }

void OffloadBundlingJobAction::anchor() { … }

OffloadBundlingJobAction::OffloadBundlingJobAction(ActionList &Inputs)
    : … { … }

void OffloadUnbundlingJobAction::anchor() { … }

OffloadUnbundlingJobAction::OffloadUnbundlingJobAction(Action *Input)
    : … { … }

void OffloadPackagerJobAction::anchor() { … }

OffloadPackagerJobAction::OffloadPackagerJobAction(ActionList &Inputs,
                                                   types::ID Type)
    : … { … }

void LinkerWrapperJobAction::anchor() { … }

LinkerWrapperJobAction::LinkerWrapperJobAction(ActionList &Inputs,
                                               types::ID Type)
    : … { … }

void StaticLibJobAction::anchor() { … }

StaticLibJobAction::StaticLibJobAction(ActionList &Inputs, types::ID Type)
    : … { … }

void BinaryAnalyzeJobAction::anchor() { … }

BinaryAnalyzeJobAction::BinaryAnalyzeJobAction(Action *Input, types::ID Type)
    : … { … }