Differential D15911 Diff 44272 lib/Driver/Action.cpp

Changeset View

Standalone View

lib/Driver/Action.cpp

	//===--- Action.cpp - Abstract compilation steps --------------------------===//			//===--- Action.cpp - Abstract compilation steps --------------------------===//
	//			//
	// The LLVM Compiler Infrastructure			// The LLVM Compiler Infrastructure
	//			//
	// This file is distributed under the University of Illinois Open Source			// This file is distributed under the University of Illinois Open Source
	// License. See LICENSE.TXT for details.			// License. See LICENSE.TXT for details.
	//			//
	//===----------------------------------------------------------------------===//			//===----------------------------------------------------------------------===//

	#include "clang/Driver/Action.h"			#include "clang/Driver/Action.h"
	#include "llvm/Support/ErrorHandling.h"			#include "llvm/Support/ErrorHandling.h"
	#include <cassert>			#include <cassert>
	using namespace clang::driver;			using namespace clang::driver;
	using namespace llvm::opt;			using namespace llvm::opt;

	Action::~Action() {			Action::~Action() {}
	if (OwnsInputs) {
	for (iterator it = begin(), ie = end(); it != ie; ++it)
	delete *it;
	}
	}

	const char *Action::getClassName(ActionClass AC) {			const char *Action::getClassName(ActionClass AC) {
	switch (AC) {			switch (AC) {
	case InputClass: return "input";			case InputClass: return "input";
	case BindArchClass: return "bind-arch";			case BindArchClass: return "bind-arch";
	case CudaDeviceClass: return "cuda-device";			case CudaDeviceClass: return "cuda-device";
	case CudaHostClass: return "cuda-host";			case CudaHostClass: return "cuda-host";
	case PreprocessJobClass: return "preprocessor";			case PreprocessJobClass: return "preprocessor";
	Show All 16 Lines
	void InputAction::anchor() {}			void InputAction::anchor() {}

	InputAction::InputAction(const Arg &_Input, types::ID _Type)			InputAction::InputAction(const Arg &_Input, types::ID _Type)
	: Action(InputClass, _Type), Input(_Input) {			: Action(InputClass, _Type), Input(_Input) {
	}			}

	void BindArchAction::anchor() {}			void BindArchAction::anchor() {}

	BindArchAction::BindArchAction(std::unique_ptr<Action> Input,			BindArchAction::BindArchAction(std::shared_ptr<Action> Input,
	const char *_ArchName)			const char *_ArchName)
	: Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}			: Action(BindArchClass, std::move(Input)), ArchName(_ArchName) {}

	void CudaDeviceAction::anchor() {}			void CudaDeviceAction::anchor() {}

	CudaDeviceAction::CudaDeviceAction(std::unique_ptr<Action> Input,			CudaDeviceAction::CudaDeviceAction(std::shared_ptr<Action> Input,
	const char *ArchName, bool AtTopLevel)			const char *ArchName, bool AtTopLevel)
	: Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),			: Action(CudaDeviceClass, std::move(Input)), GpuArchName(ArchName),
	AtTopLevel(AtTopLevel) {}			AtTopLevel(AtTopLevel) {}

	void CudaHostAction::anchor() {}			void CudaHostAction::anchor() {}

	CudaHostAction::CudaHostAction(std::unique_ptr<Action> Input,			CudaHostAction::CudaHostAction(std::shared_ptr<Action> Input,
	const ActionList &DeviceActions)			const ActionList &DeviceActions)
	: Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}			: Action(CudaHostClass, std::move(Input)), DeviceActions(DeviceActions) {}

	CudaHostAction::~CudaHostAction() {
	for (auto &DA : DeviceActions)
	delete DA;
	}

	void JobAction::anchor() {}			void JobAction::anchor() {}
				traUnsubmitted Done Reply Inline Actions I guess we no longer need this destructor. tra: I guess we no longer need this destructor.

	JobAction::JobAction(ActionClass Kind, std::unique_ptr<Action> Input,			JobAction::JobAction(ActionClass Kind, std::shared_ptr<Action> Input,
	types::ID Type)			types::ID Type)
	: Action(Kind, std::move(Input), Type) {}			: Action(Kind, std::move(Input), Type) {}

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

	void PreprocessJobAction::anchor() {}			void PreprocessJobAction::anchor() {}

	PreprocessJobAction::PreprocessJobAction(std::unique_ptr<Action> Input,			PreprocessJobAction::PreprocessJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(PreprocessJobClass, std::move(Input), OutputType) {}			: JobAction(PreprocessJobClass, std::move(Input), OutputType) {}

	void PrecompileJobAction::anchor() {}			void PrecompileJobAction::anchor() {}

	PrecompileJobAction::PrecompileJobAction(std::unique_ptr<Action> Input,			PrecompileJobAction::PrecompileJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(PrecompileJobClass, std::move(Input), OutputType) {}			: JobAction(PrecompileJobClass, std::move(Input), OutputType) {}

	void AnalyzeJobAction::anchor() {}			void AnalyzeJobAction::anchor() {}

	AnalyzeJobAction::AnalyzeJobAction(std::unique_ptr<Action> Input,			AnalyzeJobAction::AnalyzeJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}			: JobAction(AnalyzeJobClass, std::move(Input), OutputType) {}

	void MigrateJobAction::anchor() {}			void MigrateJobAction::anchor() {}

	MigrateJobAction::MigrateJobAction(std::unique_ptr<Action> Input,			MigrateJobAction::MigrateJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(MigrateJobClass, std::move(Input), OutputType) {}			: JobAction(MigrateJobClass, std::move(Input), OutputType) {}

	void CompileJobAction::anchor() {}			void CompileJobAction::anchor() {}

	CompileJobAction::CompileJobAction(std::unique_ptr<Action> Input,			CompileJobAction::CompileJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(CompileJobClass, std::move(Input), OutputType) {}			: JobAction(CompileJobClass, std::move(Input), OutputType) {}

	void BackendJobAction::anchor() {}			void BackendJobAction::anchor() {}

	BackendJobAction::BackendJobAction(std::unique_ptr<Action> Input,			BackendJobAction::BackendJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(BackendJobClass, std::move(Input), OutputType) {}			: JobAction(BackendJobClass, std::move(Input), OutputType) {}

	void AssembleJobAction::anchor() {}			void AssembleJobAction::anchor() {}

	AssembleJobAction::AssembleJobAction(std::unique_ptr<Action> Input,			AssembleJobAction::AssembleJobAction(std::shared_ptr<Action> Input,
	types::ID OutputType)			types::ID OutputType)
	: JobAction(AssembleJobClass, std::move(Input), OutputType) {}			: JobAction(AssembleJobClass, std::move(Input), OutputType) {}

	void LinkJobAction::anchor() {}			void LinkJobAction::anchor() {}

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

	void LipoJobAction::anchor() {}			void LipoJobAction::anchor() {}

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

	void DsymutilJobAction::anchor() {}			void DsymutilJobAction::anchor() {}

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

	void VerifyJobAction::anchor() {}			void VerifyJobAction::anchor() {}

	VerifyJobAction::VerifyJobAction(ActionClass Kind,			VerifyJobAction::VerifyJobAction(ActionClass Kind,
	std::unique_ptr<Action> Input, types::ID Type)			std::shared_ptr<Action> Input, types::ID Type)
	: JobAction(Kind, std::move(Input), Type) {			: JobAction(Kind, std::move(Input), Type) {
	assert((Kind == VerifyDebugInfoJobClass \|\| Kind == VerifyPCHJobClass) &&			assert((Kind == VerifyDebugInfoJobClass \|\| Kind == VerifyPCHJobClass) &&
	"ActionClass is not a valid VerifyJobAction");			"ActionClass is not a valid VerifyJobAction");
	}			}

	void VerifyDebugInfoJobAction::anchor() {}			void VerifyDebugInfoJobAction::anchor() {}

	VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(			VerifyDebugInfoJobAction::VerifyDebugInfoJobAction(
	std::unique_ptr<Action> Input, types::ID Type)			std::shared_ptr<Action> Input, types::ID Type)
	: VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}			: VerifyJobAction(VerifyDebugInfoJobClass, std::move(Input), Type) {}

	void VerifyPCHJobAction::anchor() {}			void VerifyPCHJobAction::anchor() {}

	VerifyPCHJobAction::VerifyPCHJobAction(std::unique_ptr<Action> Input,			VerifyPCHJobAction::VerifyPCHJobAction(std::shared_ptr<Action> Input,
	types::ID Type)			types::ID Type)
	: VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}			: VerifyJobAction(VerifyPCHJobClass, std::move(Input), Type) {}