WebSVN – QNX 8.QNX8 LLVM/Clang compiler suite – Blame – /llvm-build/x86_64/include/llvm/CodeGen/SelectionDAGTargetInfo.h

Rev	Author	Line No.	Line
14	pmbaty	1	//==- llvm/CodeGen/SelectionDAGTargetInfo.h - SelectionDAG Info --- C++ --==//
		2	//
		3	// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
		4	// See https://llvm.org/LICENSE.txt for license information.
		5	// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
		6	//
		7	//===----------------------------------------------------------------------===//
		8	//
		9	// This file declares the SelectionDAGTargetInfo class, which targets can
		10	// subclass to parameterize the SelectionDAG lowering and instruction
		11	// selection process.
		12	//
		13	//===----------------------------------------------------------------------===//
		14
		15	#ifndef LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H
		16	#define LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H
		17
		18	#include "llvm/CodeGen/MachineMemOperand.h"
		19	#include "llvm/CodeGen/SelectionDAGNodes.h"
		20	#include "llvm/Support/CodeGen.h"
		21	#include <utility>
		22
		23	namespace llvm {
		24
		25	class SelectionDAG;
		26
		27	//===----------------------------------------------------------------------===//
		28	/// Targets can subclass this to parameterize the
		29	/// SelectionDAG lowering and instruction selection process.
		30	///
		31	class SelectionDAGTargetInfo {
		32	public:
		33	explicit SelectionDAGTargetInfo() = default;
		34	SelectionDAGTargetInfo(const SelectionDAGTargetInfo &) = delete;
		35	SelectionDAGTargetInfo &operator=(const SelectionDAGTargetInfo &) = delete;
		36	virtual ~SelectionDAGTargetInfo();
		37
		38	/// Emit target-specific code that performs a memcpy.
		39	/// This can be used by targets to provide code sequences for cases
		40	/// that don't fit the target's parameters for simple loads/stores and can be
		41	/// more efficient than using a library call. This function can return a null
		42	/// SDValue if the target declines to use custom code and a different
		43	/// lowering strategy should be used.
		44	///
		45	/// If AlwaysInline is true, the size is constant and the target should not
		46	/// emit any calls and is strongly encouraged to attempt to emit inline code
		47	/// even if it is beyond the usual threshold because this intrinsic is being
		48	/// expanded in a place where calls are not feasible (e.g. within the prologue
		49	/// for another call). If the target chooses to decline an AlwaysInline
		50	/// request here, legalize will resort to using simple loads and stores.
		51	virtual SDValue EmitTargetCodeForMemcpy(SelectionDAG &DAG, const SDLoc &dl,
		52	SDValue Chain, SDValue Op1,
		53	SDValue Op2, SDValue Op3,
		54	Align Alignment, bool isVolatile,
		55	bool AlwaysInline,
		56	MachinePointerInfo DstPtrInfo,
		57	MachinePointerInfo SrcPtrInfo) const {
		58	return SDValue();
		59	}
		60
		61	/// Emit target-specific code that performs a memmove.
		62	/// This can be used by targets to provide code sequences for cases
		63	/// that don't fit the target's parameters for simple loads/stores and can be
		64	/// more efficient than using a library call. This function can return a null
		65	/// SDValue if the target declines to use custom code and a different
		66	/// lowering strategy should be used.
		67	virtual SDValue EmitTargetCodeForMemmove(
		68	SelectionDAG &DAG, const SDLoc &dl, SDValue Chain, SDValue Op1,
		69	SDValue Op2, SDValue Op3, Align Alignment, bool isVolatile,
		70	MachinePointerInfo DstPtrInfo, MachinePointerInfo SrcPtrInfo) const {
		71	return SDValue();
		72	}
		73
		74	/// Emit target-specific code that performs a memset.
		75	/// This can be used by targets to provide code sequences for cases
		76	/// that don't fit the target's parameters for simple stores and can be more
		77	/// efficient than using a library call. This function can return a null
		78	/// SDValue if the target declines to use custom code and a different
		79	/// lowering strategy should be used. Note that if AlwaysInline is true the
		80	/// function has to return a valid SDValue.
		81	virtual SDValue EmitTargetCodeForMemset(SelectionDAG &DAG, const SDLoc &dl,
		82	SDValue Chain, SDValue Op1,
		83	SDValue Op2, SDValue Op3,
		84	Align Alignment, bool isVolatile,
		85	bool AlwaysInline,
		86	MachinePointerInfo DstPtrInfo) const {
		87	return SDValue();
		88	}
		89
		90	/// Emit target-specific code that performs a memcmp/bcmp, in cases where that is
		91	/// faster than a libcall. The first returned SDValue is the result of the
		92	/// memcmp and the second is the chain. Both SDValues can be null if a normal
		93	/// libcall should be used.
		94	virtual std::pair<SDValue, SDValue>
		95	EmitTargetCodeForMemcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
		96	SDValue Op1, SDValue Op2, SDValue Op3,
		97	MachinePointerInfo Op1PtrInfo,
		98	MachinePointerInfo Op2PtrInfo) const {
		99	return std::make_pair(SDValue(), SDValue());
		100	}
		101
		102	/// Emit target-specific code that performs a memchr, in cases where that is
		103	/// faster than a libcall. The first returned SDValue is the result of the
		104	/// memchr and the second is the chain. Both SDValues can be null if a normal
		105	/// libcall should be used.
		106	virtual std::pair<SDValue, SDValue>
		107	EmitTargetCodeForMemchr(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
		108	SDValue Src, SDValue Char, SDValue Length,
		109	MachinePointerInfo SrcPtrInfo) const {
		110	return std::make_pair(SDValue(), SDValue());
		111	}
		112
		113	/// Emit target-specific code that performs a strcpy or stpcpy, in cases
		114	/// where that is faster than a libcall.
		115	/// The first returned SDValue is the result of the copy (the start
		116	/// of the destination string for strcpy, a pointer to the null terminator
		117	/// for stpcpy) and the second is the chain. Both SDValues can be null
		118	/// if a normal libcall should be used.
		119	virtual std::pair<SDValue, SDValue>
		120	EmitTargetCodeForStrcpy(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
		121	SDValue Dest, SDValue Src,
		122	MachinePointerInfo DestPtrInfo,
		123	MachinePointerInfo SrcPtrInfo, bool isStpcpy) const {
		124	return std::make_pair(SDValue(), SDValue());
		125	}
		126
		127	/// Emit target-specific code that performs a strcmp, in cases where that is
		128	/// faster than a libcall.
		129	/// The first returned SDValue is the result of the strcmp and the second is
		130	/// the chain. Both SDValues can be null if a normal libcall should be used.
		131	virtual std::pair<SDValue, SDValue>
		132	EmitTargetCodeForStrcmp(SelectionDAG &DAG, const SDLoc &dl, SDValue Chain,
		133	SDValue Op1, SDValue Op2,
		134	MachinePointerInfo Op1PtrInfo,
		135	MachinePointerInfo Op2PtrInfo) const {
		136	return std::make_pair(SDValue(), SDValue());
		137	}
		138
		139	virtual std::pair<SDValue, SDValue>
		140	EmitTargetCodeForStrlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
		141	SDValue Src, MachinePointerInfo SrcPtrInfo) const {
		142	return std::make_pair(SDValue(), SDValue());
		143	}
		144
		145	virtual std::pair<SDValue, SDValue>
		146	EmitTargetCodeForStrnlen(SelectionDAG &DAG, const SDLoc &DL, SDValue Chain,
		147	SDValue Src, SDValue MaxLength,
		148	MachinePointerInfo SrcPtrInfo) const {
		149	return std::make_pair(SDValue(), SDValue());
		150	}
		151
		152	virtual SDValue EmitTargetCodeForSetTag(SelectionDAG &DAG, const SDLoc &dl,
		153	SDValue Chain, SDValue Addr,
		154	SDValue Size,
		155	MachinePointerInfo DstPtrInfo,
		156	bool ZeroData) const {
		157	return SDValue();
		158	}
		159
		160	// Return true if the DAG Combiner should disable generic combines.
		161	virtual bool disableGenericCombines(CodeGenOpt::Level OptLevel) const {
		162	return false;
		163	}
		164	};
		165
		166	} // end namespace llvm
		167
		168	#endif // LLVM_CODEGEN_SELECTIONDAGTARGETINFO_H

Subversion Repositories QNX 8.QNX8 LLVM/Clang compiler suite

QNX 8.QNX8 LLVM/Clang compiler suite/llvm-build/x86_64/include/llvm/CodeGen/SelectionDAGTargetInfo.h – Rev 14