Diff 25648

llvm/trunk/docs/Statepoints.rst

Show First 20 Lines • Show All 136 Lines • ▼ Show 20 Lines
SSA value ``%obj.relocated`` which represents the potentially changed value of		SSA value ``%obj.relocated`` which represents the potentially changed value of
``%obj`` after the safepoint and update any following uses appropriately. The		``%obj`` after the safepoint and update any following uses appropriately. The
resulting relocation sequence is:		resulting relocation sequence is:

.. code-block:: llvm		.. code-block:: llvm

define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj)		define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj)
gc "statepoint-example" {		gc "statepoint-example" {
%0 = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()* @foo, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj)		%0 = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void ()* @foo, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj)
%obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 4, i32 4)		%obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 4, i32 4)
ret i8 addrspace(1)* %obj.relocated		ret i8 addrspace(1)* %obj.relocated
}		}

Ideally, this sequence would have been represented as a M argument, N		Ideally, this sequence would have been represented as a M argument, N
return value function (where M is the number of values being		return value function (where M is the number of values being
relocated + the original call arguments and N is the original return		relocated + the original call arguments and N is the original return
value + each relocated value), but LLVM does not easily support such a		value + each relocated value), but LLVM does not easily support such a
▲ Show 20 Lines • Show All 138 Lines • ▼ Show 20 Lines
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^		^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

Syntax:		Syntax:
"""""""		"""""""

::		::

declare i32		declare i32
@llvm.experimental.gc.statepoint(func_type <target>,		@llvm.experimental.gc.statepoint(i64 <id>, i32 <num patch bytes>,
		func_type <target>,
i64 <#call args>. i64 <flags>,		i64 <#call args>. i64 <flags>,
... (call parameters),		... (call parameters),
i64 <# transition args>, ... (transition parameters),		i64 <# transition args>, ... (transition parameters),
i64 <# deopt args>, ... (deopt parameters),		i64 <# deopt args>, ... (deopt parameters),
... (gc parameters))		... (gc parameters))

Overview:		Overview:
"""""""""		"""""""""

The statepoint intrinsic represents a call which is parse-able by the		The statepoint intrinsic represents a call which is parse-able by the
runtime.		runtime.

Operands:		Operands:
"""""""""		"""""""""

		The 'id' operand is a constant integer that is reported as the ID
		field in the generated stackmap. LLVM does not interpret this
		parameter in any way and its meaning is up to the statepoint user to
		decide. Note that LLVM is free to duplicate code containing
		statepoint calls, and this may transform IR that had a unique 'id' per
		lexical call to statepoint to IR that does not.

		If 'num patch bytes' is non-zero then the call instruction
		corresponding to the statepoint is not emitted and LLVM emits 'num
		patch bytes' bytes of nops in its place. LLVM will emit code to
		prepare the function arguments and retrieve the function return value
		in accordance to the calling convention; the former before the nop
		sequence and the latter after the nop sequence. It is expected that
		the user will patch over the 'num patch bytes' bytes of nops with a
		calling sequence specific to their runtime before executing the
		generated machine code. There are no guarantees with respect to the
		alignment of the nop sequence. Unlike :doc:`StackMaps` statepoints do
		not have a concept of shadow bytes.

The 'target' operand is the function actually being called. The		The 'target' operand is the function actually being called. The
target can be specified as either a symbolic LLVM function, or as an		target can be specified as either a symbolic LLVM function, or as an
arbitrary Value of appropriate function type. Note that the function		arbitrary Value of appropriate function type. Note that the function
type must match the signature of the callee and the types of the 'call		type must match the signature of the callee and the types of the 'call
parameters' arguments.		parameters' arguments. If 'num patch bytes' is non-zero then 'target'
		has to be the constant pointer null of the appropriate function type.

The '#call args' operand is the number of arguments to the actual		The '#call args' operand is the number of arguments to the actual
call. It must exactly match the number of arguments passed in the		call. It must exactly match the number of arguments passed in the
'call parameters' variable length section.		'call parameters' variable length section.

The 'flags' operand is used to specify extra information about the		The 'flags' operand is used to specify extra information about the
statepoint. This is currently only used to mark certain statepoints		statepoint. This is currently only used to mark certain statepoints
as GC transitions. This operand is a 64-bit integer with the following		as GC transitions. This operand is a 64-bit integer with the following
▲ Show 20 Lines • Show All 172 Lines • ▼ Show 20 Lines	* Variable number of Locations pairs, one pair for each unique pointer
statepoint. There may be fewer pairs then gc parameters in the IR		statepoint. There may be fewer pairs then gc parameters in the IR
statepoint. Each unique pair will occur at least once; duplicates		statepoint. Each unique pair will occur at least once; duplicates
are possible.		are possible.

Note that the Locations used in each section may describe the same		Note that the Locations used in each section may describe the same
physical location. e.g. A stack slot may appear as a deopt location,		physical location. e.g. A stack slot may appear as a deopt location,
a gc base pointer, and a gc derived pointer.		a gc base pointer, and a gc derived pointer.

The ID field of the 'StkMapRecord' for a statepoint is meaningless and
it's value is explicitly unspecified.

The LiveOut section of the StkMapRecord will be empty for a statepoint		The LiveOut section of the StkMapRecord will be empty for a statepoint
record.		record.

Safepoint Semantics & Verification		Safepoint Semantics & Verification
==================================		==================================

The fundamental correctness property for the compiled code's		The fundamental correctness property for the compiled code's
correctness w.r.t. the garbage collector is a dynamic one. It must be		correctness w.r.t. the garbage collector is a dynamic one. It must be
▲ Show 20 Lines • Show All 162 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/CodeGen/StackMaps.h

Show First 20 Lines • Show All 79 Lines • ▼ Show 20 Lines	public:

/// \brief Get the next scratch register operand index.		/// \brief Get the next scratch register operand index.
unsigned getNextScratchIdx(unsigned StartIdx = 0) const;		unsigned getNextScratchIdx(unsigned StartIdx = 0) const;
};		};

/// MI-level Statepoint operands		/// MI-level Statepoint operands
///		///
/// Statepoint operands take the form:		/// Statepoint operands take the form:
/// <num call arguments>, <call target>, [call arguments],		/// <id>, <num patch bytes >, <num call arguments>, <call target>,
/// <StackMaps::ConstantOp>, <calling convention>,		/// [call arguments], <StackMaps::ConstantOp>, <calling convention>,
/// <StackMaps::ConstantOp>, <statepoint flags>,		/// <StackMaps::ConstantOp>, <statepoint flags>,
/// <StackMaps::ConstantOp>, <num other args>, [other args],		/// <StackMaps::ConstantOp>, <num other args>, [other args],
/// [gc values]		/// [gc values]
class StatepointOpers {		class StatepointOpers {
private:		private:
// These values are aboolute offsets into the operands of the statepoint		// These values are aboolute offsets into the operands of the statepoint
// instruction.		// instruction.
enum {		enum { IDPos, NBytesPos, NCallArgsPos, CallTargetPos, MetaEnd };
NCallArgsPos = 0,
CallTargetPos = 1
};

// These values are relative offests from the start of the statepoint meta		// These values are relative offests from the start of the statepoint meta
// arguments (i.e. the end of the call arguments).		// arguments (i.e. the end of the call arguments).
enum {		enum {
CCOffset = 1,		CCOffset = 1,
FlagsOffset = 3,		FlagsOffset = 3,
NumVMSArgsOffset = 5		NumVMSArgsOffset = 5
};		};

public:		public:
explicit StatepointOpers(const MachineInstr *MI):		explicit StatepointOpers(const MachineInstr *MI):
MI(MI) { }		MI(MI) { }

/// Get starting index of non call related arguments		/// Get starting index of non call related arguments
/// (calling convention, statepoint flags, vm state and gc state).		/// (calling convention, statepoint flags, vm state and gc state).
unsigned getVarIdx() const {		unsigned getVarIdx() const {
return MI->getOperand(NCallArgsPos).getImm() + 2;		return MI->getOperand(NCallArgsPos).getImm() + MetaEnd;
}		}

/// Returns the index of the operand containing the number of non-gc non-call		/// Return the ID for the given statepoint.
/// arguments.		uint64_t getID() const { return MI->getOperand(IDPos).getImm(); }
unsigned getNumVMSArgsIdx() const {
return getVarIdx() + NumVMSArgsOffset;
}

/// Returns the number of non-gc non-call arguments attached to the		/// Return the number of patchable bytes the given statepoint should emit.
/// statepoint. Note that this is the number of arguments, not the number of		uint32_t getNumPatchBytes() const {
/// operands required to represent those arguments.		return MI->getOperand(NBytesPos).getImm();
unsigned getNumVMSArgs() const {
return MI->getOperand(getNumVMSArgsIdx()).getImm();
}		}

/// Returns the target of the underlying call.		/// Returns the target of the underlying call.
const MachineOperand &getCallTarget() const {		const MachineOperand &getCallTarget() const {
return MI->getOperand(CallTargetPos);		return MI->getOperand(CallTargetPos);
}		}

private:		private:
▲ Show 20 Lines • Show All 130 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/IRBuilder.h

Show First 20 Lines • Show All 441 Lines • ▼ Show 20 Lines	CallInst CreateMaskedStore(Value Val, Value *Ptr, unsigned Align,
Value *Mask);		Value *Mask);

/// \brief Create an assume intrinsic call that allows the optimizer to		/// \brief Create an assume intrinsic call that allows the optimizer to
/// assume that the provided condition will be true.		/// assume that the provided condition will be true.
CallInst CreateAssumption(Value Cond);		CallInst CreateAssumption(Value Cond);

/// \brief Create a call to the experimental.gc.statepoint intrinsic to		/// \brief Create a call to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.		/// start a new statepoint sequence.
CallInst CreateGCStatepointCall(Value ActualCallee,		CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
		Value *ActualCallee,
ArrayRef<Value *> CallArgs,		ArrayRef<Value *> CallArgs,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value *> DeoptArgs,
ArrayRef<Value *> GCArgs,		ArrayRef<Value *> GCArgs,
const Twine &Name = "");		const Twine &Name = "");

// \brief Conveninence function for the common case when CallArgs are filled		// \brief Conveninence function for the common case when CallArgs are filled
// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be		// in using makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be
// .get()'ed to get the Value pointer.		// .get()'ed to get the Value pointer.
CallInst CreateGCStatepointCall(Value ActualCallee, ArrayRef<Use> CallArgs,		CallInst *CreateGCStatepointCall(uint64_t ID, uint32_t NumPatchBytes,
		Value *ActualCallee, ArrayRef<Use> CallArgs,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value *> DeoptArgs,
ArrayRef<Value *> GCArgs,		ArrayRef<Value *> GCArgs,
const Twine &Name = "");		const Twine &Name = "");

/// brief Create an invoke to the experimental.gc.statepoint intrinsic to		/// brief Create an invoke to the experimental.gc.statepoint intrinsic to
/// start a new statepoint sequence.		/// start a new statepoint sequence.
InvokeInst *		InvokeInst *
CreateGCStatepointInvoke(Value ActualInvokee, BasicBlock NormalDest,		CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
		Value ActualInvokee, BasicBlock NormalDest,
BasicBlock UnwindDest, ArrayRef<Value > InvokeArgs,		BasicBlock UnwindDest, ArrayRef<Value > InvokeArgs,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value *> DeoptArgs,
ArrayRef<Value *> GCArgs, const Twine &Name = "");		ArrayRef<Value *> GCArgs, const Twine &Name = "");

// Conveninence function for the common case when CallArgs are filled in using		// Conveninence function for the common case when CallArgs are filled in using
// makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to		// makeArrayRef(CS.arg_begin(), CS.arg_end()); Use needs to be .get()'ed to
// get the Value *.		// get the Value *.
InvokeInst *		InvokeInst *
CreateGCStatepointInvoke(Value ActualInvokee, BasicBlock NormalDest,		CreateGCStatepointInvoke(uint64_t ID, uint32_t NumPatchBytes,
		Value ActualInvokee, BasicBlock NormalDest,
BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,		BasicBlock *UnwindDest, ArrayRef<Use> InvokeArgs,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value *> DeoptArgs,
ArrayRef<Value *> GCArgs, const Twine &Name = "");		ArrayRef<Value *> GCArgs, const Twine &Name = "");

/// \brief Create a call to the experimental.gc.result intrinsic to extract		/// \brief Create a call to the experimental.gc.result intrinsic to extract
/// the result from a call wrapped in a statepoint.		/// the result from a call wrapped in a statepoint.
CallInst CreateGCResult(Instruction Statepoint,		CallInst CreateGCResult(Instruction Statepoint,
Type *ResultType,		Type *ResultType,
▲ Show 20 Lines • Show All 1,213 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Intrinsics.td

Show First 20 Lines • Show All 522 Lines • ▼ Show 20 Lines	def int_experimental_patchpoint_i64 : Intrinsic<[llvm_i64_ty],
llvm_vararg_ty],		llvm_vararg_ty],
[Throws]>;		[Throws]>;


//===------------------------ Garbage Collection Intrinsics ---------------===//		//===------------------------ Garbage Collection Intrinsics ---------------===//
// These are documented in docs/Statepoint.rst		// These are documented in docs/Statepoint.rst

def int_experimental_gc_statepoint : Intrinsic<[llvm_i32_ty],		def int_experimental_gc_statepoint : Intrinsic<[llvm_i32_ty],
[llvm_anyptr_ty, llvm_i32_ty,		[llvm_i64_ty, llvm_i32_ty,
		llvm_anyptr_ty, llvm_i32_ty,
llvm_i32_ty, llvm_vararg_ty]>;		llvm_i32_ty, llvm_vararg_ty]>;

def int_experimental_gc_result : Intrinsic<[llvm_any_ty], [llvm_i32_ty]>;		def int_experimental_gc_result : Intrinsic<[llvm_any_ty], [llvm_i32_ty]>;
def int_experimental_gc_relocate : Intrinsic<[llvm_anyptr_ty],		def int_experimental_gc_relocate : Intrinsic<[llvm_anyptr_ty],
[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty]>;		[llvm_i32_ty, llvm_i32_ty, llvm_i32_ty]>;

// Deprecated: will be removed in a couple of weeks		// Deprecated: will be removed in a couple of weeks
def int_experimental_gc_result_int : Intrinsic<[llvm_anyint_ty], [llvm_i32_ty]>;		def int_experimental_gc_result_int : Intrinsic<[llvm_anyint_ty], [llvm_i32_ty]>;
▲ Show 20 Lines • Show All 93 Lines • Show Last 20 Lines

llvm/trunk/include/llvm/IR/Statepoint.h

Show First 20 Lines • Show All 68 Lines • ▼ Show 20 Lines	protected:
explicit StatepointBase(CallSiteTy CS) : StatepointCS(CS) {		explicit StatepointBase(CallSiteTy CS) : StatepointCS(CS) {
assert(isStatepoint(CS));		assert(isStatepoint(CS));
}		}

public:		public:
typedef typename CallSiteTy::arg_iterator arg_iterator;		typedef typename CallSiteTy::arg_iterator arg_iterator;

enum {		enum {
ActualCalleePos = 0,		IDPos = 0,
NumCallArgsPos = 1,		NumPatchBytesPos = 1,
CallArgsBeginPos = 3,		ActualCalleePos = 2,
		NumCallArgsPos = 3,
		FlagsPos = 4,
		CallArgsBeginPos = 5,
};		};

/// Return the underlying CallSite.		/// Return the underlying CallSite.
CallSiteTy getCallSite() { return StatepointCS; }		CallSiteTy getCallSite() { return StatepointCS; }

uint64_t getFlags() const {		uint64_t getFlags() const {
return cast<ConstantInt>(StatepointCS.getArgument(2))->getZExtValue();		return cast<ConstantInt>(StatepointCS.getArgument(FlagsPos))
		->getZExtValue();
		}

		/// Return the ID associated with this statepoint.
		uint64_t getID() {
		const Value *IDVal = StatepointCS.getArgument(IDPos);
		return cast<ConstantInt>(IDVal)->getZExtValue();
		}

		/// Return the number of patchable bytes associated with this statepoint.
		uint32_t getNumPatchBytes() {
		const Value *NumPatchBytesVal = StatepointCS.getArgument(NumPatchBytesPos);
		uint64_t NumPatchBytes =
		cast<ConstantInt>(NumPatchBytesVal)->getZExtValue();
		assert(isInt<32>(NumPatchBytes) && "should fit in 32 bits!");
		return NumPatchBytes;
}		}

/// Return the value actually being called or invoked.		/// Return the value actually being called or invoked.
ValueTy *getActualCallee() {		ValueTy *getActualCallee() {
return StatepointCS.getArgument(ActualCalleePos);		return StatepointCS.getArgument(ActualCalleePos);
}		}

/// Return the type of the value returned by the call underlying the		/// Return the type of the value returned by the call underlying the
▲ Show 20 Lines • Show All 241 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/SelectionDAG/StatepointLowering.cpp

Show First 20 Lines • Show All 577 Lines • ▼ Show 20 Lines	#endif

// Get call node, we will replace it later with statepoint		// Get call node, we will replace it later with statepoint
SDNode *CallNode =		SDNode *CallNode =
lowerCallFromStatepoint(ISP, LandingPad, *this, PendingExports);		lowerCallFromStatepoint(ISP, LandingPad, *this, PendingExports);

// Construct the actual GC_TRANSITION_START, STATEPOINT, and GC_TRANSITION_END		// Construct the actual GC_TRANSITION_START, STATEPOINT, and GC_TRANSITION_END
// nodes with all the appropriate arguments and return values.		// nodes with all the appropriate arguments and return values.

// TODO: Currently, all of these operands are being marked as read/write in
// PrologEpilougeInserter.cpp, we should special case the VMState arguments
// and flags to be read-only.
SmallVector<SDValue, 40> Ops;

// Call Node: Chain, Target, {Args}, RegMask, [Glue]		// Call Node: Chain, Target, {Args}, RegMask, [Glue]
SDValue Chain = CallNode->getOperand(0);		SDValue Chain = CallNode->getOperand(0);

SDValue Glue;		SDValue Glue;
bool CallHasIncomingGlue = CallNode->getGluedNode();		bool CallHasIncomingGlue = CallNode->getGluedNode();
if (CallHasIncomingGlue) {		if (CallHasIncomingGlue) {
// Glue is always last operand		// Glue is always last operand
Glue = CallNode->getOperand(CallNode->getNumOperands() - 1);		Glue = CallNode->getOperand(CallNode->getNumOperands() - 1);
Show All 30 Lines	if (IsGCTransition) {

SDValue GCTransitionStart =		SDValue GCTransitionStart =
DAG.getNode(ISD::GC_TRANSITION_START, getCurSDLoc(), NodeTys, TSOps);		DAG.getNode(ISD::GC_TRANSITION_START, getCurSDLoc(), NodeTys, TSOps);

Chain = GCTransitionStart.getValue(0);		Chain = GCTransitionStart.getValue(0);
Glue = GCTransitionStart.getValue(1);		Glue = GCTransitionStart.getValue(1);
}		}

		// TODO: Currently, all of these operands are being marked as read/write in
		// PrologEpilougeInserter.cpp, we should special case the VMState arguments
		// and flags to be read-only.
		SmallVector<SDValue, 40> Ops;

		// Add the <id> and <numBytes> constants.
		Ops.push_back(DAG.getTargetConstant(ISP.getID(), getCurSDLoc(), MVT::i64));
		Ops.push_back(
		DAG.getTargetConstant(ISP.getNumPatchBytes(), getCurSDLoc(), MVT::i32));

// Calculate and push starting position of vmstate arguments		// Calculate and push starting position of vmstate arguments
// Get number of arguments incoming directly into call node		// Get number of arguments incoming directly into call node
unsigned NumCallRegArgs =		unsigned NumCallRegArgs =
CallNode->getNumOperands() - (CallHasIncomingGlue ? 4 : 3);		CallNode->getNumOperands() - (CallHasIncomingGlue ? 4 : 3);
Ops.push_back(DAG.getTargetConstant(NumCallRegArgs, getCurSDLoc(), MVT::i32));		Ops.push_back(DAG.getTargetConstant(NumCallRegArgs, getCurSDLoc(), MVT::i32));

// Add call target		// Add call target
SDValue CallTarget = SDValue(CallNode->getOperand(1).getNode(), 0);		SDValue CallTarget = SDValue(CallNode->getOperand(1).getNode(), 0);
Ops.push_back(CallTarget);		Ops.push_back(CallTarget);

// Add call arguments		// Add call arguments
// Get position of register mask in the call		// Get position of register mask in the call
SDNode::op_iterator RegMaskIt;		SDNode::op_iterator RegMaskIt;
if (CallHasIncomingGlue)		if (CallHasIncomingGlue)
RegMaskIt = CallNode->op_end() - 2;		RegMaskIt = CallNode->op_end() - 2;
else		else
RegMaskIt = CallNode->op_end() - 1;		RegMaskIt = CallNode->op_end() - 1;
Ops.insert(Ops.end(), CallNode->op_begin() + 2, RegMaskIt);		Ops.insert(Ops.end(), CallNode->op_begin() + 2, RegMaskIt);

// Add a constant argument for the calling convention		// Add a constant argument for the calling convention
pushStackMapConstant(Ops, *this, CS.getCallingConv());		pushStackMapConstant(Ops, *this, CS.getCallingConv());

// Add a constant argument for the flags		// Add a constant argument for the flags
uint64_t Flags = cast<ConstantInt>(CS.getArgument(2))->getZExtValue();		uint64_t Flags = ISP.getFlags();
assert(		assert(
((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0)		((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0)
&& "unknown flag used");		&& "unknown flag used");
pushStackMapConstant(Ops, *this, Flags);		pushStackMapConstant(Ops, *this, Flags);

// Insert all vmstate and gcstate arguments		// Insert all vmstate and gcstate arguments
Ops.insert(Ops.end(), LoweredMetaArgs.begin(), LoweredMetaArgs.end());		Ops.insert(Ops.end(), LoweredMetaArgs.begin(), LoweredMetaArgs.end());

▲ Show 20 Lines • Show All 127 Lines • Show Last 20 Lines

llvm/trunk/lib/CodeGen/StackMaps.cpp

	Show First 20 Lines • Show All 364 Lines • ▼ Show 20 Lines
	void StackMaps::recordStatepoint(const MachineInstr &MI) {			void StackMaps::recordStatepoint(const MachineInstr &MI) {
	assert(MI.getOpcode() == TargetOpcode::STATEPOINT &&			assert(MI.getOpcode() == TargetOpcode::STATEPOINT &&
	"expected statepoint");			"expected statepoint");

	StatepointOpers opers(&MI);			StatepointOpers opers(&MI);
	// Record all the deopt and gc operands (they're contiguous and run from the			// Record all the deopt and gc operands (they're contiguous and run from the
	// initial index to the end of the operand list)			// initial index to the end of the operand list)
	const unsigned StartIdx = opers.getVarIdx();			const unsigned StartIdx = opers.getVarIdx();
	recordStackMapOpers(MI, 0xABCDEF00,			recordStackMapOpers(MI, opers.getID(), MI.operands_begin() + StartIdx,
	MI.operands_begin() + StartIdx, MI.operands_end(),			MI.operands_end(), false);
	false);
	}			}

	/// Emit the stackmap header.			/// Emit the stackmap header.
	///			///
	/// Header {			/// Header {
	/// uint8 : Stack Map Version (currently 1)			/// uint8 : Stack Map Version (currently 1)
	/// uint8 : Reserved (expected to be 0)			/// uint8 : Reserved (expected to be 0)
	/// uint16 : Reserved (expected to be 0)			/// uint16 : Reserved (expected to be 0)
	▲ Show 20 Lines • Show All 163 Lines • Show Last 20 Lines

llvm/trunk/lib/IR/IRBuilder.cpp

Show First 20 Lines • Show All 239 Lines • ▼ Show 20 Lines	CallInst *IRBuilderBase::CreateMaskedIntrinsic(unsigned Id,
Type *DataTy,		Type *DataTy,
const Twine &Name) {		const Twine &Name) {
Module *M = BB->getParent()->getParent();		Module *M = BB->getParent()->getParent();
Type *OverloadedTypes[] = { DataTy };		Type *OverloadedTypes[] = { DataTy };
Value *TheFn = Intrinsic::getDeclaration(M, (Intrinsic::ID)Id, OverloadedTypes);		Value *TheFn = Intrinsic::getDeclaration(M, (Intrinsic::ID)Id, OverloadedTypes);
return createCallHelper(TheFn, Ops, this, Name);		return createCallHelper(TheFn, Ops, this, Name);
}		}

static std::vector<Value *> getStatepointArgs(IRBuilderBase &B,		static std::vector<Value *>
Value *ActualCallee,		getStatepointArgs(IRBuilderBase &B, uint64_t ID, uint32_t NumPatchBytes,
ArrayRef<Value *> CallArgs,		Value ActualCallee, ArrayRef<Value > CallArgs,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value > DeoptArgs, ArrayRef<Value > GCArgs) {
ArrayRef<Value *> GCArgs) {
std::vector<Value *> Args;		std::vector<Value *> Args;
		Args.push_back(B.getInt64(ID));
		Args.push_back(B.getInt32(NumPatchBytes));
Args.push_back(ActualCallee);		Args.push_back(ActualCallee);
Args.push_back(B.getInt32(CallArgs.size()));		Args.push_back(B.getInt32(CallArgs.size()));
Args.push_back(B.getInt32((unsigned)StatepointFlags::None));		Args.push_back(B.getInt32((unsigned)StatepointFlags::None));
Args.insert(Args.end(), CallArgs.begin(), CallArgs.end());		Args.insert(Args.end(), CallArgs.begin(), CallArgs.end());
Args.push_back(B.getInt32(0 /* no transition args */));		Args.push_back(B.getInt32(0 /* no transition args */));
Args.push_back(B.getInt32(DeoptArgs.size()));		Args.push_back(B.getInt32(DeoptArgs.size()));
Args.insert(Args.end(), DeoptArgs.begin(), DeoptArgs.end());		Args.insert(Args.end(), DeoptArgs.begin(), DeoptArgs.end());
Args.insert(Args.end(), GCArgs.begin(), GCArgs.end());		Args.insert(Args.end(), GCArgs.begin(), GCArgs.end());

return Args;		return Args;
}		}

CallInst IRBuilderBase::CreateGCStatepointCall(Value ActualCallee,		CallInst *IRBuilderBase::CreateGCStatepointCall(
ArrayRef<Value *> CallArgs,		uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Value > CallArgs, ArrayRef<Value > DeoptArgs,
ArrayRef<Value *> GCArgs,		ArrayRef<Value *> GCArgs, const Twine &Name) {
const Twine &Name) {
// Extract out the type of the callee.		// Extract out the type of the callee.
PointerType *FuncPtrType = cast<PointerType>(ActualCallee->getType());		PointerType *FuncPtrType = cast<PointerType>(ActualCallee->getType());
assert(isa<FunctionType>(FuncPtrType->getElementType()) &&		assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
"actual callee must be a callable value");		"actual callee must be a callable value");

Module *M = BB->getParent()->getParent();		Module *M = BB->getParent()->getParent();
// Fill in the one generic type'd argument (the function is also vararg)		// Fill in the one generic type'd argument (the function is also vararg)
Type *ArgTypes[] = { FuncPtrType };		Type *ArgTypes[] = { FuncPtrType };
Function *FnStatepoint =		Function *FnStatepoint =
Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint,		Intrinsic::getDeclaration(M, Intrinsic::experimental_gc_statepoint,
ArgTypes);		ArgTypes);

std::vector<llvm::Value *> Args =		std::vector<llvm::Value *> Args = getStatepointArgs(
getStatepointArgs(*this, ActualCallee, CallArgs, DeoptArgs, GCArgs);		*this, ID, NumPatchBytes, ActualCallee, CallArgs, DeoptArgs, GCArgs);
return createCallHelper(FnStatepoint, Args, this, Name);		return createCallHelper(FnStatepoint, Args, this, Name);
}		}

CallInst IRBuilderBase::CreateGCStatepointCall(Value ActualCallee,		CallInst *IRBuilderBase::CreateGCStatepointCall(
ArrayRef<Use> CallArgs,		uint64_t ID, uint32_t NumPatchBytes, Value *ActualCallee,
ArrayRef<Value *> DeoptArgs,		ArrayRef<Use> CallArgs, ArrayRef<Value *> DeoptArgs,
ArrayRef<Value *> GCArgs,		ArrayRef<Value *> GCArgs, const Twine &Name) {
const Twine &Name) {
std::vector<Value *> VCallArgs;		std::vector<Value *> VCallArgs;
for (auto &U : CallArgs)		for (auto &U : CallArgs)
VCallArgs.push_back(U.get());		VCallArgs.push_back(U.get());
return CreateGCStatepointCall(ActualCallee, VCallArgs, DeoptArgs, GCArgs,		return CreateGCStatepointCall(ID, NumPatchBytes, ActualCallee, VCallArgs,
Name);		DeoptArgs, GCArgs, Name);
}		}

InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(		InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
Value ActualInvokee, BasicBlock NormalDest, BasicBlock *UnwindDest,		uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
		BasicBlock NormalDest, BasicBlock UnwindDest,
ArrayRef<Value > InvokeArgs, ArrayRef<Value > DeoptArgs,		ArrayRef<Value > InvokeArgs, ArrayRef<Value > DeoptArgs,
ArrayRef<Value *> GCArgs, const Twine &Name) {		ArrayRef<Value *> GCArgs, const Twine &Name) {
// Extract out the type of the callee.		// Extract out the type of the callee.
PointerType *FuncPtrType = cast<PointerType>(ActualInvokee->getType());		PointerType *FuncPtrType = cast<PointerType>(ActualInvokee->getType());
assert(isa<FunctionType>(FuncPtrType->getElementType()) &&		assert(isa<FunctionType>(FuncPtrType->getElementType()) &&
"actual callee must be a callable value");		"actual callee must be a callable value");

Module *M = BB->getParent()->getParent();		Module *M = BB->getParent()->getParent();
// Fill in the one generic type'd argument (the function is also vararg)		// Fill in the one generic type'd argument (the function is also vararg)
Function *FnStatepoint = Intrinsic::getDeclaration(		Function *FnStatepoint = Intrinsic::getDeclaration(
M, Intrinsic::experimental_gc_statepoint, {FuncPtrType});		M, Intrinsic::experimental_gc_statepoint, {FuncPtrType});

std::vector<llvm::Value *> Args =		std::vector<llvm::Value *> Args = getStatepointArgs(
getStatepointArgs(*this, ActualInvokee, InvokeArgs, DeoptArgs, GCArgs);		*this, ID, NumPatchBytes, ActualInvokee, InvokeArgs, DeoptArgs, GCArgs);
return createInvokeHelper(FnStatepoint, NormalDest, UnwindDest, Args, this,		return createInvokeHelper(FnStatepoint, NormalDest, UnwindDest, Args, this,
Name);		Name);
}		}

InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(		InvokeInst *IRBuilderBase::CreateGCStatepointInvoke(
Value ActualInvokee, BasicBlock NormalDest, BasicBlock *UnwindDest,		uint64_t ID, uint32_t NumPatchBytes, Value *ActualInvokee,
ArrayRef<Use> InvokeArgs, ArrayRef<Value *> DeoptArgs,		BasicBlock NormalDest, BasicBlock UnwindDest, ArrayRef<Use> InvokeArgs,
ArrayRef<Value *> GCArgs, const Twine &Name) {		ArrayRef<Value > DeoptArgs, ArrayRef<Value > GCArgs, const Twine &Name) {
std::vector<Value *> VCallArgs;		std::vector<Value *> VCallArgs;
for (auto &U : InvokeArgs)		for (auto &U : InvokeArgs)
VCallArgs.push_back(U.get());		VCallArgs.push_back(U.get());
return CreateGCStatepointInvoke(ActualInvokee, NormalDest, UnwindDest,		return CreateGCStatepointInvoke(ID, NumPatchBytes, ActualInvokee, NormalDest,
VCallArgs, DeoptArgs, GCArgs, Name);		UnwindDest, VCallArgs, DeoptArgs, GCArgs,
		Name);
}		}

CallInst IRBuilderBase::CreateGCResult(Instruction Statepoint,		CallInst IRBuilderBase::CreateGCResult(Instruction Statepoint,
Type *ResultType,		Type *ResultType,
const Twine &Name) {		const Twine &Name) {
Intrinsic::ID ID = Intrinsic::experimental_gc_result;		Intrinsic::ID ID = Intrinsic::experimental_gc_result;
Module *M = BB->getParent()->getParent();		Module *M = BB->getParent()->getParent();
Type *Types[] = {ResultType};		Type *Types[] = {ResultType};
Show All 21 Lines

llvm/trunk/lib/IR/Verifier.cpp

Show First 20 Lines • Show All 1,493 Lines • ▼ Show 20 Lines	void Verifier::VerifyStatepoint(ImmutableCallSite CS) {

const Instruction &CI = *CS.getInstruction();		const Instruction &CI = *CS.getInstruction();

Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(),		Assert(!CS.doesNotAccessMemory() && !CS.onlyReadsMemory(),
"gc.statepoint must read and write memory to preserve "		"gc.statepoint must read and write memory to preserve "
"reordering restrictions required by safepoint semantics",		"reordering restrictions required by safepoint semantics",
&CI);		&CI);

const Value *Target = CS.getArgument(0);		const Value *IDV = CS.getArgument(0);
		Assert(isa<ConstantInt>(IDV), "gc.statepoint ID must be a constant integer",
		&CI);

		const Value *NumPatchBytesV = CS.getArgument(1);
		Assert(isa<ConstantInt>(NumPatchBytesV),
		"gc.statepoint number of patchable bytes must be a constant integer",
		&CI);
		const uint64_t NumPatchBytes =
		cast<ConstantInt>(NumPatchBytesV)->getSExtValue();
		assert(isInt<32>(NumPatchBytes) && "NumPatchBytesV is an i32!");
		Assert(NumPatchBytes >= 0, "gc.statepoint number of patchable bytes must be "
		"positive",
		&CI);

		const Value *Target = CS.getArgument(2);
const PointerType *PT = dyn_cast<PointerType>(Target->getType());		const PointerType *PT = dyn_cast<PointerType>(Target->getType());
Assert(PT && PT->getElementType()->isFunctionTy(),		Assert(PT && PT->getElementType()->isFunctionTy(),
"gc.statepoint callee must be of function pointer type", &CI, Target);		"gc.statepoint callee must be of function pointer type", &CI, Target);
FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());		FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());

const Value *NumCallArgsV = CS.getArgument(1);		if (NumPatchBytes)
		Assert(isa<ConstantPointerNull>(Target->stripPointerCasts()),
		"gc.statepoint must have null as call target if number of patchable "
		"bytes is non zero",
		&CI);

		const Value *NumCallArgsV = CS.getArgument(3);
Assert(isa<ConstantInt>(NumCallArgsV),		Assert(isa<ConstantInt>(NumCallArgsV),
"gc.statepoint number of arguments to underlying call "		"gc.statepoint number of arguments to underlying call "
"must be constant integer",		"must be constant integer",
&CI);		&CI);
const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();		const int NumCallArgs = cast<ConstantInt>(NumCallArgsV)->getZExtValue();
Assert(NumCallArgs >= 0,		Assert(NumCallArgs >= 0,
"gc.statepoint number of arguments to underlying call "		"gc.statepoint number of arguments to underlying call "
"must be positive",		"must be positive",
&CI);		&CI);
const int NumParams = (int)TargetFuncType->getNumParams();		const int NumParams = (int)TargetFuncType->getNumParams();
if (TargetFuncType->isVarArg()) {		if (TargetFuncType->isVarArg()) {
Assert(NumCallArgs >= NumParams,		Assert(NumCallArgs >= NumParams,
"gc.statepoint mismatch in number of vararg call args", &CI);		"gc.statepoint mismatch in number of vararg call args", &CI);

// TODO: Remove this limitation		// TODO: Remove this limitation
Assert(TargetFuncType->getReturnType()->isVoidTy(),		Assert(TargetFuncType->getReturnType()->isVoidTy(),
"gc.statepoint doesn't support wrapping non-void "		"gc.statepoint doesn't support wrapping non-void "
"vararg functions yet",		"vararg functions yet",
&CI);		&CI);
} else		} else
Assert(NumCallArgs == NumParams,		Assert(NumCallArgs == NumParams,
"gc.statepoint mismatch in number of call args", &CI);		"gc.statepoint mismatch in number of call args", &CI);

const Value *FlagsV = CS.getArgument(2);		const Value *FlagsV = CS.getArgument(4);
Assert(isa<ConstantInt>(FlagsV),		Assert(isa<ConstantInt>(FlagsV),
"gc.statepoint flags must be constant integer", &CI);		"gc.statepoint flags must be constant integer", &CI);
const uint64_t Flags = cast<ConstantInt>(FlagsV)->getZExtValue();		const uint64_t Flags = cast<ConstantInt>(FlagsV)->getZExtValue();
Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,		Assert((Flags & ~(uint64_t)StatepointFlags::MaskAll) == 0,
"unknown flag used in gc.statepoint flags argument", &CI);		"unknown flag used in gc.statepoint flags argument", &CI);

// Verify that the types of the call parameter arguments match		// Verify that the types of the call parameter arguments match
// the type of the wrapped callee.		// the type of the wrapped callee.
for (int i = 0; i < NumParams; i++) {		for (int i = 0; i < NumParams; i++) {
Type *ParamType = TargetFuncType->getParamType(i);		Type *ParamType = TargetFuncType->getParamType(i);
Type *ArgType = CS.getArgument(3+i)->getType();		Type *ArgType = CS.getArgument(5 + i)->getType();
Assert(ArgType == ParamType,		Assert(ArgType == ParamType,
"gc.statepoint call argument does not match wrapped "		"gc.statepoint call argument does not match wrapped "
"function type",		"function type",
&CI);		&CI);
}		}
const int EndCallArgsInx = 2+NumCallArgs;
		const int EndCallArgsInx = 4 + NumCallArgs;

const Value *NumTransitionArgsV = CS.getArgument(EndCallArgsInx+1);		const Value *NumTransitionArgsV = CS.getArgument(EndCallArgsInx+1);
Assert(isa<ConstantInt>(NumTransitionArgsV),		Assert(isa<ConstantInt>(NumTransitionArgsV),
"gc.statepoint number of transition arguments "		"gc.statepoint number of transition arguments "
"must be constant integer",		"must be constant integer",
&CI);		&CI);
const int NumTransitionArgs =		const int NumTransitionArgs =
cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();		cast<ConstantInt>(NumTransitionArgsV)->getZExtValue();
Assert(NumTransitionArgs >= 0,		Assert(NumTransitionArgs >= 0,
"gc.statepoint number of transition arguments must be positive", &CI);		"gc.statepoint number of transition arguments must be positive", &CI);
const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;		const int EndTransitionArgsInx = EndCallArgsInx + 1 + NumTransitionArgs;

const Value *NumDeoptArgsV = CS.getArgument(EndTransitionArgsInx+1);		const Value *NumDeoptArgsV = CS.getArgument(EndTransitionArgsInx+1);
Assert(isa<ConstantInt>(NumDeoptArgsV),		Assert(isa<ConstantInt>(NumDeoptArgsV),
"gc.statepoint number of deoptimization arguments "		"gc.statepoint number of deoptimization arguments "
"must be constant integer",		"must be constant integer",
&CI);		&CI);
const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();		const int NumDeoptArgs = cast<ConstantInt>(NumDeoptArgsV)->getZExtValue();
Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments "		Assert(NumDeoptArgs >= 0, "gc.statepoint number of deoptimization arguments "
"must be positive",		"must be positive",
&CI);		&CI);

const int ExpectedNumArgs =		const int ExpectedNumArgs =
5 + NumCallArgs + NumTransitionArgs + NumDeoptArgs;		7 + NumCallArgs + NumTransitionArgs + NumDeoptArgs;
Assert(ExpectedNumArgs <= (int)CS.arg_size(),		Assert(ExpectedNumArgs <= (int)CS.arg_size(),
"gc.statepoint too few arguments according to length fields", &CI);		"gc.statepoint too few arguments according to length fields", &CI);

// Check that the only uses of this gc.statepoint are gc.result or		// Check that the only uses of this gc.statepoint are gc.result or
// gc.relocate calls which are tied to this statepoint and thus part		// gc.relocate calls which are tied to this statepoint and thus part
// of the same statepoint sequence		// of the same statepoint sequence
for (const User *U : CI.users()) {		for (const User *U : CI.users()) {
const CallInst *Call = dyn_cast<const CallInst>(U);		const CallInst *Call = dyn_cast<const CallInst>(U);
▲ Show 20 Lines • Show All 1,702 Lines • ▼ Show 20 Lines	const Function *StatepointFn =
StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr;		StatepointCS.getInstruction() ? StatepointCS.getCalledFunction() : nullptr;
Assert(StatepointFn && StatepointFn->isDeclaration() &&		Assert(StatepointFn && StatepointFn->isDeclaration() &&
StatepointFn->getIntrinsicID() ==		StatepointFn->getIntrinsicID() ==
Intrinsic::experimental_gc_statepoint,		Intrinsic::experimental_gc_statepoint,
"gc.result operand #1 must be from a statepoint", &CI,		"gc.result operand #1 must be from a statepoint", &CI,
CI.getArgOperand(0));		CI.getArgOperand(0));

// Assert that result type matches wrapped callee.		// Assert that result type matches wrapped callee.
const Value *Target = StatepointCS.getArgument(0);		const Value *Target = StatepointCS.getArgument(2);
const PointerType *PT = cast<PointerType>(Target->getType());		const PointerType *PT = cast<PointerType>(Target->getType());
const FunctionType *TargetFuncType =		const FunctionType *TargetFuncType =
cast<FunctionType>(PT->getElementType());		cast<FunctionType>(PT->getElementType());
Assert(CI.getType() == TargetFuncType->getReturnType(),		Assert(CI.getType() == TargetFuncType->getReturnType(),
"gc.result result type does not match wrapped callee", &CI);		"gc.result result type does not match wrapped callee", &CI);
break;		break;
}		}
case Intrinsic::experimental_gc_relocate: {		case Intrinsic::experimental_gc_relocate: {
▲ Show 20 Lines • Show All 50 Lines • ▼ Show 20 Lines	Assert(0 <= BaseIndex && BaseIndex < (int)StatepointCS.arg_size(),
"gc.relocate: statepoint base index out of bounds", &CI);		"gc.relocate: statepoint base index out of bounds", &CI);
Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(),		Assert(0 <= DerivedIndex && DerivedIndex < (int)StatepointCS.arg_size(),
"gc.relocate: statepoint derived index out of bounds", &CI);		"gc.relocate: statepoint derived index out of bounds", &CI);

// Check that BaseIndex and DerivedIndex fall within the 'gc parameters'		// Check that BaseIndex and DerivedIndex fall within the 'gc parameters'
// section of the statepoint's argument		// section of the statepoint's argument
Assert(StatepointCS.arg_size() > 0,		Assert(StatepointCS.arg_size() > 0,
"gc.statepoint: insufficient arguments");		"gc.statepoint: insufficient arguments");
Assert(isa<ConstantInt>(StatepointCS.getArgument(1)),		Assert(isa<ConstantInt>(StatepointCS.getArgument(3)),
"gc.statement: number of call arguments must be constant integer");		"gc.statement: number of call arguments must be constant integer");
const unsigned NumCallArgs =		const unsigned NumCallArgs =
cast<ConstantInt>(StatepointCS.getArgument(1))->getZExtValue();		cast<ConstantInt>(StatepointCS.getArgument(3))->getZExtValue();
Assert(StatepointCS.arg_size() > NumCallArgs+3,		Assert(StatepointCS.arg_size() > NumCallArgs + 5,
"gc.statepoint: mismatch in number of call arguments");		"gc.statepoint: mismatch in number of call arguments");
Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs+3)),		Assert(isa<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5)),
"gc.statepoint: number of transition arguments must be "		"gc.statepoint: number of transition arguments must be "
"a constant integer");		"a constant integer");
const int NumTransitionArgs =		const int NumTransitionArgs =
cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 3))->getZExtValue();		cast<ConstantInt>(StatepointCS.getArgument(NumCallArgs + 5))
const int DeoptArgsStart = 2 + NumCallArgs + 1 + NumTransitionArgs + 1;		->getZExtValue();
		const int DeoptArgsStart = 4 + NumCallArgs + 1 + NumTransitionArgs + 1;
Assert(isa<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart)),		Assert(isa<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart)),
"gc.statepoint: number of deoptimization arguments must be "		"gc.statepoint: number of deoptimization arguments must be "
"a constant integer");		"a constant integer");
const int NumDeoptArgs =		const int NumDeoptArgs =
cast<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart))->getZExtValue();		cast<ConstantInt>(StatepointCS.getArgument(DeoptArgsStart))->getZExtValue();
const int GCParamArgsStart = DeoptArgsStart + 1 + NumDeoptArgs;		const int GCParamArgsStart = DeoptArgsStart + 1 + NumDeoptArgs;
const int GCParamArgsEnd = StatepointCS.arg_size();		const int GCParamArgsEnd = StatepointCS.arg_size();
Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,		Assert(GCParamArgsStart <= BaseIndex && BaseIndex < GCParamArgsEnd,
▲ Show 20 Lines • Show All 281 Lines • Show Last 20 Lines

llvm/trunk/lib/Target/X86/X86MCInstLower.cpp

Show First 20 Lines • Show All 806 Lines • ▼ Show 20 Lines	while (NumBytes) {
}		}
} // while (NumBytes)		} // while (NumBytes)
}		}

void X86AsmPrinter::LowerSTATEPOINT(const MachineInstr &MI,		void X86AsmPrinter::LowerSTATEPOINT(const MachineInstr &MI,
X86MCInstLower &MCIL) {		X86MCInstLower &MCIL) {
assert(Subtarget->is64Bit() && "Statepoint currently only supports X86-64");		assert(Subtarget->is64Bit() && "Statepoint currently only supports X86-64");

		StatepointOpers SOpers(&MI);

		if (unsigned PatchBytes = SOpers.getNumPatchBytes()) {
		EmitNops(*OutStreamer, PatchBytes, Subtarget->is64Bit(),
		getSubtargetInfo());
		} else {
// Lower call target and choose correct opcode		// Lower call target and choose correct opcode
const MachineOperand &CallTarget = StatepointOpers(&MI).getCallTarget();		const MachineOperand &CallTarget = SOpers.getCallTarget();
MCOperand CallTargetMCOp;		MCOperand CallTargetMCOp;
unsigned CallOpcode;		unsigned CallOpcode;
switch (CallTarget.getType()) {		switch (CallTarget.getType()) {
case MachineOperand::MO_GlobalAddress:		case MachineOperand::MO_GlobalAddress:
case MachineOperand::MO_ExternalSymbol:		case MachineOperand::MO_ExternalSymbol:
CallTargetMCOp = MCIL.LowerSymbolOperand(		CallTargetMCOp = MCIL.LowerSymbolOperand(
CallTarget, MCIL.GetSymbolFromOperand(CallTarget));		CallTarget, MCIL.GetSymbolFromOperand(CallTarget));
CallOpcode = X86::CALL64pcrel32;		CallOpcode = X86::CALL64pcrel32;
// Currently, we only support relative addressing with statepoints.		// Currently, we only support relative addressing with statepoints.
// Otherwise, we'll need a scratch register to hold the target		// Otherwise, we'll need a scratch register to hold the target
// address. You'll fail asserts during load & relocation if this		// address. You'll fail asserts during load & relocation if this
// symbol is to far away. (TODO: support non-relative addressing)		// symbol is to far away. (TODO: support non-relative addressing)
break;		break;
case MachineOperand::MO_Immediate:		case MachineOperand::MO_Immediate:
CallTargetMCOp = MCOperand::CreateImm(CallTarget.getImm());		CallTargetMCOp = MCOperand::CreateImm(CallTarget.getImm());
CallOpcode = X86::CALL64pcrel32;		CallOpcode = X86::CALL64pcrel32;
// Currently, we only support relative addressing with statepoints.		// Currently, we only support relative addressing with statepoints.
// Otherwise, we'll need a scratch register to hold the target		// Otherwise, we'll need a scratch register to hold the target
// immediate. You'll fail asserts during load & relocation if this		// immediate. You'll fail asserts during load & relocation if this
// address is to far away. (TODO: support non-relative addressing)		// address is to far away. (TODO: support non-relative addressing)
break;		break;
case MachineOperand::MO_Register:		case MachineOperand::MO_Register:
CallTargetMCOp = MCOperand::CreateReg(CallTarget.getReg());		CallTargetMCOp = MCOperand::CreateReg(CallTarget.getReg());
CallOpcode = X86::CALL64r;		CallOpcode = X86::CALL64r;
break;		break;
default:		default:
llvm_unreachable("Unsupported operand type in statepoint call target");		llvm_unreachable("Unsupported operand type in statepoint call target");
break;		break;
}		}

// Emit call		// Emit call
MCInst CallInst;		MCInst CallInst;
CallInst.setOpcode(CallOpcode);		CallInst.setOpcode(CallOpcode);
CallInst.addOperand(CallTargetMCOp);		CallInst.addOperand(CallTargetMCOp);
OutStreamer->EmitInstruction(CallInst, getSubtargetInfo());		OutStreamer->EmitInstruction(CallInst, getSubtargetInfo());
		}

// Record our statepoint node in the same section used by STACKMAP		// Record our statepoint node in the same section used by STACKMAP
// and PATCHPOINT		// and PATCHPOINT
SM.recordStatepoint(MI);		SM.recordStatepoint(MI);
}		}


// Lower a stackmap of the form:		// Lower a stackmap of the form:
▲ Show 20 Lines • Show All 449 Lines • Show Last 20 Lines

llvm/trunk/lib/Transforms/Scalar/PlaceSafepoints.cpp

Show First 20 Lines • Show All 898 Lines • ▼ Show 20 Lines	static Value ReplaceWithStatepoint(const CallSite &CS, / to replace */

// Create the statepoint given all the arguments		// Create the statepoint given all the arguments
Instruction *Token = nullptr;		Instruction *Token = nullptr;
AttributeSet OriginalAttrs;		AttributeSet OriginalAttrs;

if (CS.isCall()) {		if (CS.isCall()) {
CallInst *ToReplace = cast<CallInst>(CS.getInstruction());		CallInst *ToReplace = cast<CallInst>(CS.getInstruction());
CallInst *Call = Builder.CreateGCStatepointCall(		CallInst *Call = Builder.CreateGCStatepointCall(
CS.getCalledValue(), makeArrayRef(CS.arg_begin(), CS.arg_end()), None,		0xABCDEF00, 0, CS.getCalledValue(), makeArrayRef(CS.arg_begin(), CS.arg_end()),
None, "safepoint_token");		None, None, "safepoint_token");
Call->setTailCall(ToReplace->isTailCall());		Call->setTailCall(ToReplace->isTailCall());
Call->setCallingConv(ToReplace->getCallingConv());		Call->setCallingConv(ToReplace->getCallingConv());

// Before we have to worry about GC semantics, all attributes are legal		// Before we have to worry about GC semantics, all attributes are legal
// TODO: handle param attributes		// TODO: handle param attributes
OriginalAttrs = ToReplace->getAttributes();		OriginalAttrs = ToReplace->getAttributes();

// In case if we can handle this set of attributes - set up function		// In case if we can handle this set of attributes - set up function
Show All 11 Lines	static Value ReplaceWithStatepoint(const CallSite &CS, / to replace */
} else if (CS.isInvoke()) {		} else if (CS.isInvoke()) {
InvokeInst *ToReplace = cast<InvokeInst>(CS.getInstruction());		InvokeInst *ToReplace = cast<InvokeInst>(CS.getInstruction());

// Insert the new invoke into the old block. We'll remove the old one in a		// Insert the new invoke into the old block. We'll remove the old one in a
// moment at which point this will become the new terminator for the		// moment at which point this will become the new terminator for the
// original block.		// original block.
Builder.SetInsertPoint(ToReplace->getParent());		Builder.SetInsertPoint(ToReplace->getParent());
InvokeInst *Invoke = Builder.CreateGCStatepointInvoke(		InvokeInst *Invoke = Builder.CreateGCStatepointInvoke(
CS.getCalledValue(), ToReplace->getNormalDest(),		0xABCDEF00, 0, CS.getCalledValue(), ToReplace->getNormalDest(),
ToReplace->getUnwindDest(), makeArrayRef(CS.arg_begin(), CS.arg_end()),		ToReplace->getUnwindDest(), makeArrayRef(CS.arg_begin(), CS.arg_end()),
Builder.getInt32(0), None, "safepoint_token");		Builder.getInt32(0), None, "safepoint_token");

// Currently we will fail on parameter attributes and on certain		// Currently we will fail on parameter attributes and on certain
// function attributes.		// function attributes.
OriginalAttrs = ToReplace->getAttributes();		OriginalAttrs = ToReplace->getAttributes();

// In case if we can handle this set of attributes - set up function		// In case if we can handle this set of attributes - set up function
Show All 33 Lines

llvm/trunk/test/Analysis/ValueTracking/memory-dereferenceable.ll

	Show All 16 Lines
	; CHECK: %relocate			; CHECK: %relocate
	; CHECK-NOT: %nparam			; CHECK-NOT: %nparam
	entry:			entry:
	%globalptr = getelementptr inbounds [6 x i8], [6 x i8]* @globalstr, i32 0, i32 0			%globalptr = getelementptr inbounds [6 x i8], [6 x i8]* @globalstr, i32 0, i32 0
	%load1 = load i8, i8* %globalptr			%load1 = load i8, i8* %globalptr
	%alloca = alloca i1			%alloca = alloca i1
	%load2 = load i1, i1* %alloca			%load2 = load i1, i1* %alloca
	%load3 = load i32, i32 addrspace(1)* %dparam			%load3 = load i32, i32 addrspace(1)* %dparam
	%tok = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)			%tok = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)
	%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %tok, i32 5, i32 5)			%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %tok, i32 7, i32 7)
	%load4 = load i32, i32 addrspace(1)* %relocate			%load4 = load i32, i32 addrspace(1)* %relocate
	%nparam = getelementptr i32, i32 addrspace(1)* %dparam, i32 5			%nparam = getelementptr i32, i32 addrspace(1)* %dparam, i32 5
	%load5 = load i32, i32 addrspace(1)* %nparam			%load5 = load i32, i32 addrspace(1)* %nparam
	ret void			ret void
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)
				No newline at end of file

llvm/trunk/test/CodeGen/Generic/overloaded-intrinsic-name.ll

	; RUN: opt -verify -S < %s			; RUN: opt -verify -S < %s

	; Tests the name mangling performed by the codepath following			; Tests the name mangling performed by the codepath following
	; getMangledTypeStr(). Only tests that code with the various manglings			; getMangledTypeStr(). Only tests that code with the various manglings
	; run fine: doesn't actually test the mangling with the type of the			; run fine: doesn't actually test the mangling with the type of the
	; arguments. Meant to serve as an example-document on how the user			; arguments. Meant to serve as an example-document on how the user
	; should do name manglings.			; should do name manglings.

	; Exercise the most general case, llvm_anyptr_type, using gc.relocate			; Exercise the most general case, llvm_anyptr_type, using gc.relocate
	; and gc.statepoint. Note that it has nothing to do with gc.*			; and gc.statepoint. Note that it has nothing to do with gc.*
	; functions specifically: any function that accepts llvm_anyptr_type			; functions specifically: any function that accepts llvm_anyptr_type
	; will serve the purpose.			; will serve the purpose.

	; function and integer			; function and integer
	define i32* @test_iAny(i32* %v) gc "statepoint-example" {			define i32* @test_iAny(i32* %v) gc "statepoint-example" {
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %v)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %v)
	%v-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 5)			%v-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 7)
	ret i32* %v-new			ret i32* %v-new
	}			}

	; float			; float
	define float* @test_fAny(float* %v) gc "statepoint-example" {			define float* @test_fAny(float* %v) gc "statepoint-example" {
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, float* %v)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, float* %v)
	%v-new = call float* @llvm.experimental.gc.relocate.p0f32(i32 %tok, i32 5, i32 5)			%v-new = call float* @llvm.experimental.gc.relocate.p0f32(i32 %tok, i32 7, i32 7)
	ret float* %v-new			ret float* %v-new
	}			}

	; array of integers			; array of integers
	define [3 x i32]* @test_aAny([3 x i32]* %v) gc "statepoint-example" {			define [3 x i32]* @test_aAny([3 x i32]* %v) gc "statepoint-example" {
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %v)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %v)
	%v-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 5, i32 5)			%v-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 7, i32 7)
	ret [3 x i32]* %v-new			ret [3 x i32]* %v-new
	}			}

	; vector of integers			; vector of integers
	define <3 x i32>* @test_vAny(<3 x i32>* %v) gc "statepoint-example" {			define <3 x i32>* @test_vAny(<3 x i32>* %v) gc "statepoint-example" {
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, <3 x i32>* %v)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, <3 x i32>* %v)
	%v-new = call <3 x i32>* @llvm.experimental.gc.relocate.p0v3i32(i32 %tok, i32 5, i32 5)			%v-new = call <3 x i32>* @llvm.experimental.gc.relocate.p0v3i32(i32 %tok, i32 7, i32 7)
	ret <3 x i32>* %v-new			ret <3 x i32>* %v-new
	}			}

	%struct.test = type { i32, i1 }			%struct.test = type { i32, i1 }

	; struct			; struct
	define %struct.test* @test_struct(%struct.test* %v) gc "statepoint-example" {			define %struct.test* @test_struct(%struct.test* %v) gc "statepoint-example" {
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, %struct.test* %v)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, %struct.test* %v)
	%v-new = call %struct.test* @llvm.experimental.gc.relocate.p0struct.test(i32 %tok, i32 5, i32 5)			%v-new = call %struct.test* @llvm.experimental.gc.relocate.p0struct.test(i32 %tok, i32 7, i32 7)
	ret %struct.test* %v-new			ret %struct.test* %v-new
	}			}

	declare zeroext i1 @return_i1()			declare zeroext i1 @return_i1()
	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i32* @llvm.experimental.gc.relocate.p0i32(i32, i32, i32)			declare i32* @llvm.experimental.gc.relocate.p0i32(i32, i32, i32)
	declare float* @llvm.experimental.gc.relocate.p0f32(i32, i32, i32)			declare float* @llvm.experimental.gc.relocate.p0f32(i32, i32, i32)
	declare [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32, i32, i32)			declare [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32, i32, i32)
	declare <3 x i32>* @llvm.experimental.gc.relocate.p0v3i32(i32, i32, i32)			declare <3 x i32>* @llvm.experimental.gc.relocate.p0v3i32(i32, i32, i32)
	declare %struct.test* @llvm.experimental.gc.relocate.p0struct.test(i32, i32, i32)			declare %struct.test* @llvm.experimental.gc.relocate.p0struct.test(i32, i32, i32)

llvm/trunk/test/CodeGen/X86/statepoint-allocas.ll

	Show All 15 Lines
	; CHECK: movq %rdi, (%rsp)			; CHECK: movq %rdi, (%rsp)
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: movq (%rsp), %rax			; CHECK: movq (%rsp), %rax
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%alloca = alloca i32 addrspace(1)*, align 8			%alloca = alloca i32 addrspace(1)*, align 8
	store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca			store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca
	call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)** %alloca)			call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)** %alloca)
	%rel = load i32 addrspace(1), i32 addrspace(1)* %alloca			%rel = load i32 addrspace(1), i32 addrspace(1)* %alloca
	ret i32 addrspace(1)* %rel			ret i32 addrspace(1)* %rel
	}			}

	; Can we handle an alloca as a deopt value?			; Can we handle an alloca as a deopt value?
	define i32 addrspace(1)* @test2(i32 addrspace(1)* %ptr) gc "statepoint-example" {			define i32 addrspace(1)* @test2(i32 addrspace(1)* %ptr) gc "statepoint-example" {
	; CHECK-LABEL: test2			; CHECK-LABEL: test2
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: movq %rdi, (%rsp)			; CHECK: movq %rdi, (%rsp)
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: xorl %eax, %eax			; CHECK: xorl %eax, %eax
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%alloca = alloca i32 addrspace(1)*, align 8			%alloca = alloca i32 addrspace(1)*, align 8
	store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca			store i32 addrspace(1)* %ptr, i32 addrspace(1)** %alloca
	call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 1, i32 addrspace(1)** %alloca)			call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 1, i32 addrspace(1)** %alloca)
	ret i32 addrspace(1)* null			ret i32 addrspace(1)* null
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)


	; CHECK-LABEL: .section .llvm_stackmaps			; CHECK-LABEL: .section .llvm_stackmaps
	; CHECK-NEXT: __LLVM_StackMaps:			; CHECK-NEXT: __LLVM_StackMaps:
	; Header			; Header
	; CHECK-NEXT: .byte 1			; CHECK-NEXT: .byte 1
	; CHECK-NEXT: .byte 0			; CHECK-NEXT: .byte 0
	; CHECK-NEXT: .short 0			; CHECK-NEXT: .short 0
	; Num Functions			; Num Functions
	; CHECK-NEXT: .long 2			; CHECK-NEXT: .long 2
	; Num LargeConstants			; Num LargeConstants
	; CHECK-NEXT: .long 0			; CHECK-NEXT: .long 0
	; Num Callsites			; Num Callsites
	; CHECK-NEXT: .long 2			; CHECK-NEXT: .long 2

	; Functions and stack size			; Functions and stack size
	; CHECK-NEXT: .quad test			; CHECK-NEXT: .quad test
	; CHECK-NEXT: .quad 8			; CHECK-NEXT: .quad 8
	; CHECK-NEXT: .quad test2			; CHECK-NEXT: .quad test2
	; CHECK-NEXT: .quad 8			; CHECK-NEXT: .quad 8

	; Large Constants			; Large Constants
	; Statepoint ID only			; Statepoint ID only
	; CHECK: .quad 2882400000			; CHECK: .quad 0

	; Callsites			; Callsites
	; The GC one			; The GC one
	; CHECK: .long .Ltmp1-test			; CHECK: .long .Ltmp1-test
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .short 4			; CHECK: .short 4
	; SmallConstant (0)			; SmallConstant (0)
	; CHECK: .byte 4			; CHECK: .byte 4
	▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
	; CHECK: .short 7			; CHECK: .short 7
	; CHECK: .long 0			; CHECK: .long 0

	; No Padding or LiveOuts			; No Padding or LiveOuts
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .align 8			; CHECK: .align 8

llvm/trunk/test/CodeGen/X86/statepoint-call-lowering.ll

	Show All 14 Lines
	; CHECK-LABEL: test_i1_return			; CHECK-LABEL: test_i1_return
	; This is just checking that a i1 gets lowered normally when there's no extra			; This is just checking that a i1 gets lowered normally when there's no extra
	; state arguments to the statepoint			; state arguments to the statepoint
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0)
	%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	ret i1 %call1			ret i1 %call1
	}			}

	define i32 @test_i32_return() gc "statepoint-example" {			define i32 @test_i32_return() gc "statepoint-example" {
	; CHECK-LABEL: test_i32_return			; CHECK-LABEL: test_i32_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32			; CHECK: callq return_i32
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i32 () @return_i32, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 0, i32 0, i32 () @return_i32, i32 0, i32 0, i32 0, i32 0)
	%call1 = call zeroext i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)			%call1 = call zeroext i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)
	ret i32 %call1			ret i32 %call1
	}			}

	define i32* @test_i32ptr_return() gc "statepoint-example" {			define i32* @test_i32ptr_return() gc "statepoint-example" {
	; CHECK-LABEL: test_i32ptr_return			; CHECK-LABEL: test_i32ptr_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32ptr			; CHECK: callq return_i32ptr
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i32* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p0i32f(i32 ()* @return_i32ptr, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i32* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p0i32f(i64 0, i32 0, i32 ()* @return_i32ptr, i32 0, i32 0, i32 0, i32 0)
	%call1 = call i32* @llvm.experimental.gc.result.p0i32(i32 %safepoint_token)			%call1 = call i32* @llvm.experimental.gc.result.p0i32(i32 %safepoint_token)
	ret i32* %call1			ret i32* %call1
	}			}

	define float @test_float_return() gc "statepoint-example" {			define float @test_float_return() gc "statepoint-example" {
	; CHECK-LABEL: test_float_return			; CHECK-LABEL: test_float_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_float			; CHECK: callq return_float
	; CHECK: popq %rax			; CHECK: popq %rax
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (float (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_f32f(float () @return_float, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, float (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_f32f(i64 0, i32 0, float () @return_float, i32 0, i32 0, i32 0, i32 0)
	%call1 = call float @llvm.experimental.gc.result.f32(i32 %safepoint_token)			%call1 = call float @llvm.experimental.gc.result.f32(i32 %safepoint_token)
	ret float %call1			ret float %call1
	}			}

	define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" {			define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" {
	; CHECK-LABEL: test_relocate			; CHECK-LABEL: test_relocate
	; Check that an ununsed relocate has no code-generation impact			; Check that an ununsed relocate has no code-generation impact
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK-NEXT: .Ltmp9:			; CHECK-NEXT: .Ltmp9:
	; CHECK-NEXT: popq %rdx			; CHECK-NEXT: popq %rdx
	; CHECK-NEXT: retq			; CHECK-NEXT: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %a)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %a)
	%call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%call2 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call2 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	ret i1 %call2			ret i1 %call2
	}			}

	define void @test_void_vararg() gc "statepoint-example" {			define void @test_void_vararg() gc "statepoint-example" {
	; CHECK-LABEL: test_void_vararg			; CHECK-LABEL: test_void_vararg
	; Check a statepoint wrapping a void returning vararg function works			; Check a statepoint wrapping a void returning vararg function works
	; CHECK: callq varargf			; CHECK: callq varargf
	entry:			entry:
	%safepoint_token = tail call i32 (void (i32, ...), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(void (i32, ...) @varargf, i32 2, i32 0, i32 42, i32 43, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, void (i32, ...), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(i64 0, i32 0, void (i32, ...) @varargf, i32 2, i32 0, i32 42, i32 43, i32 0, i32 0)
	;; if we try to use the result from a statepoint wrapping a			;; if we try to use the result from a statepoint wrapping a
	;; non-void-returning varargf, we will experience a crash.			;; non-void-returning varargf, we will experience a crash.
	ret void			ret void
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			define i1 @test_i1_return_patchable() gc "statepoint-example" {
				; CHECK-LABEL: test_i1_return_patchable
				; A patchable variant of test_i1_return
				; CHECK: pushq %rax
				; CHECK: nopl
				; CHECK: popq %rdx
				; CHECK: retq
				entry:
				%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 3, i1 ()null, i32 0, i32 0, i32 0, i32 0)
				%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
				ret i1 %call1
				}

				declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i1 @llvm.experimental.gc.result.i1(i32)			declare i1 @llvm.experimental.gc.result.i1(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_i32f(i32 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i32f(i64, i32, i32 ()*, i32, i32, ...)
	declare i32 @llvm.experimental.gc.result.i32(i32)			declare i32 @llvm.experimental.gc.result.i32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_p0i32f(i32* ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_p0i32f(i64, i32, i32* ()*, i32, i32, ...)
	declare i32* @llvm.experimental.gc.result.p0i32(i32)			declare i32* @llvm.experimental.gc.result.p0i32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_f32f(float ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_f32f(i64, i32, float ()*, i32, i32, ...)
	declare float @llvm.experimental.gc.result.f32(i32)			declare float @llvm.experimental.gc.result.f32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(void (i32, ...)*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(i64, i32, void (i32, ...)*, i32, i32, ...)

	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)

llvm/trunk/test/CodeGen/X86/statepoint-forward.ll

	Show All 19 Lines
	;; Forwarding the value of a pointer load is invalid since it may have			;; Forwarding the value of a pointer load is invalid since it may have
	;; changed at the safepoint. Forwarding a non-gc pointer value would			;; changed at the safepoint. Forwarding a non-gc pointer value would
	;; be valid, but is not currently implemented.			;; be valid, but is not currently implemented.
	define i1 @test_load_forward(i32 addrspace(1)* addrspace(1)* %p) gc "statepoint-example" {			define i1 @test_load_forward(i32 addrspace(1)* addrspace(1)* %p) gc "statepoint-example" {
	entry:			entry:
	%before = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %p			%before = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %p
	%cmp1 = call i1 @f(i32 addrspace(1)* %before)			%cmp1 = call i1 @f(i32 addrspace(1)* %before)
	call void @llvm.assume(i1 %cmp1)			call void @llvm.assume(i1 %cmp1)
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* addrspace(1)* %p)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* addrspace(1)* %p)
	%pnew = call i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32 %safepoint_token, i32 7, i32 7)
	%after = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %pnew			%after = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %pnew
	%cmp2 = call i1 @f(i32 addrspace(1)* %after)			%cmp2 = call i1 @f(i32 addrspace(1)* %after)
	ret i1 %cmp2			ret i1 %cmp2

	; CHECK-OPT-LABEL: test_load_forward			; CHECK-OPT-LABEL: test_load_forward
	; CHECK-OPT: ret i1 %cmp2			; CHECK-OPT: ret i1 %cmp2
	; CHECK-LLC-LABEL: test_load_forward			; CHECK-LLC-LABEL: test_load_forward
	; CHECK-LLC: callq f			; CHECK-LLC: callq f
	}			}

	;; Same as above, but forwarding from a store			;; Same as above, but forwarding from a store
	define i1 @test_store_forward(i32 addrspace(1)* addrspace(1)* %p,			define i1 @test_store_forward(i32 addrspace(1)* addrspace(1)* %p,
	i32 addrspace(1)* %v) gc "statepoint-example" {			i32 addrspace(1)* %v) gc "statepoint-example" {
	entry:			entry:
	%cmp1 = call i1 @f(i32 addrspace(1)* %v)			%cmp1 = call i1 @f(i32 addrspace(1)* %v)
	call void @llvm.assume(i1 %cmp1)			call void @llvm.assume(i1 %cmp1)
	store i32 addrspace(1)* %v, i32 addrspace(1)* addrspace(1)* %p			store i32 addrspace(1)* %v, i32 addrspace(1)* addrspace(1)* %p
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* addrspace(1)* %p)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* addrspace(1)* %p)
	%pnew = call i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32 %safepoint_token, i32 7, i32 7)
	%after = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %pnew			%after = load i32 addrspace(1), i32 addrspace(1) addrspace(1)* %pnew
	%cmp2 = call i1 @f(i32 addrspace(1)* %after)			%cmp2 = call i1 @f(i32 addrspace(1)* %after)
	ret i1 %cmp2			ret i1 %cmp2

	; CHECK-OPT-LABEL: test_store_forward			; CHECK-OPT-LABEL: test_store_forward
	; CHECK-OPT: ret i1 %cmp2			; CHECK-OPT: ret i1 %cmp2
	; CHECK-LLC-LABEL: test_store_forward			; CHECK-LLC-LABEL: test_store_forward
	; CHECK-LLC: callq f			; CHECK-LLC: callq f
	Show All 10 Lines
	; that is not itself GC managed. The GC may have an external mechanism			; that is not itself GC managed. The GC may have an external mechanism
	; to know about and update that value at a safepoint. Note that the			; to know about and update that value at a safepoint. Note that the
	; statepoint does not provide the collector with this root.			; statepoint does not provide the collector with this root.
	define i1 @test_load_forward_nongc_heap(i32 addrspace(1)** %p) gc "statepoint-example" {			define i1 @test_load_forward_nongc_heap(i32 addrspace(1)** %p) gc "statepoint-example" {
	entry:			entry:
	%before = load i32 addrspace(1), i32 addrspace(1)* %p			%before = load i32 addrspace(1), i32 addrspace(1)* %p
	%cmp1 = call i1 @f(i32 addrspace(1)* %before)			%cmp1 = call i1 @f(i32 addrspace(1)* %before)
	call void @llvm.assume(i1 %cmp1)			call void @llvm.assume(i1 %cmp1)
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0)
	%after = load i32 addrspace(1), i32 addrspace(1)* %p			%after = load i32 addrspace(1), i32 addrspace(1)* %p
	%cmp2 = call i1 @f(i32 addrspace(1)* %after)			%cmp2 = call i1 @f(i32 addrspace(1)* %after)
	ret i1 %cmp2			ret i1 %cmp2

	; CHECK-OPT-LABEL: test_load_forward_nongc_heap			; CHECK-OPT-LABEL: test_load_forward_nongc_heap
	; CHECK-OPT: ret i1 %cmp2			; CHECK-OPT: ret i1 %cmp2
	; CHECK-LLC-LABEL: test_load_forward_nongc_heap			; CHECK-LLC-LABEL: test_load_forward_nongc_heap
	; CHECK-LLC: callq f			; CHECK-LLC: callq f
	}			}

	;; Same as above, but forwarding from a store			;; Same as above, but forwarding from a store
	define i1 @test_store_forward_nongc_heap(i32 addrspace(1)** %p,			define i1 @test_store_forward_nongc_heap(i32 addrspace(1)** %p,
	i32 addrspace(1)* %v) gc "statepoint-example" {			i32 addrspace(1)* %v) gc "statepoint-example" {
	entry:			entry:
	%cmp1 = call i1 @f(i32 addrspace(1)* %v)			%cmp1 = call i1 @f(i32 addrspace(1)* %v)
	call void @llvm.assume(i1 %cmp1)			call void @llvm.assume(i1 %cmp1)
	store i32 addrspace(1)* %v, i32 addrspace(1)** %p			store i32 addrspace(1)* %v, i32 addrspace(1)** %p
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0)
	%after = load i32 addrspace(1), i32 addrspace(1)* %p			%after = load i32 addrspace(1), i32 addrspace(1)* %p
	%cmp2 = call i1 @f(i32 addrspace(1)* %after)			%cmp2 = call i1 @f(i32 addrspace(1)* %after)
	ret i1 %cmp2			ret i1 %cmp2

	; CHECK-OPT-LABEL: test_store_forward_nongc_heap			; CHECK-OPT-LABEL: test_store_forward_nongc_heap
	; CHECK-OPT: ret i1 %cmp2			; CHECK-OPT: ret i1 %cmp2
	; CHECK-LLC-LABEL: test_store_forward_nongc_heap			; CHECK-LLC-LABEL: test_store_forward_nongc_heap
	; CHECK-LLC: callq f			; CHECK-LLC: callq f
	}			}

	declare void @llvm.assume(i1)			declare void @llvm.assume(i1)
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
	declare i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32, i32, i32) #3			declare i32 addrspace(1)* addrspace(1)* @llvm.experimental.gc.relocate.p1p1i32(i32, i32, i32) #3

llvm/trunk/test/CodeGen/X86/statepoint-gctransition-call-lowering.ll

	Show All 15 Lines
	; CHECK-LABEL: test_i1_return			; CHECK-LABEL: test_i1_return
	; This is just checking that a i1 gets lowered normally when there's no extra			; This is just checking that a i1 gets lowered normally when there's no extra
	; state arguments to the statepoint			; state arguments to the statepoint
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 1, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 1, i32 0, i32 0)
	%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	ret i1 %call1			ret i1 %call1
	}			}

	define i32 @test_i32_return() gc "statepoint-example" {			define i32 @test_i32_return() gc "statepoint-example" {
	; CHECK-LABEL: test_i32_return			; CHECK-LABEL: test_i32_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32			; CHECK: callq return_i32
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i32 () @return_i32, i32 0, i32 1, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 0, i32 0, i32 () @return_i32, i32 0, i32 1, i32 0, i32 0)
	%call1 = call zeroext i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)			%call1 = call zeroext i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)
	ret i32 %call1			ret i32 %call1
	}			}

	define i32* @test_i32ptr_return() gc "statepoint-example" {			define i32* @test_i32ptr_return() gc "statepoint-example" {
	; CHECK-LABEL: test_i32ptr_return			; CHECK-LABEL: test_i32ptr_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32ptr			; CHECK: callq return_i32ptr
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i32* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p0i32f(i32 ()* @return_i32ptr, i32 0, i32 1, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, i32* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p0i32f(i64 0, i32 0, i32 ()* @return_i32ptr, i32 0, i32 1, i32 0, i32 0)
	%call1 = call i32* @llvm.experimental.gc.result.p0i32(i32 %safepoint_token)			%call1 = call i32* @llvm.experimental.gc.result.p0i32(i32 %safepoint_token)
	ret i32* %call1			ret i32* %call1
	}			}

	define float @test_float_return() gc "statepoint-example" {			define float @test_float_return() gc "statepoint-example" {
	; CHECK-LABEL: test_float_return			; CHECK-LABEL: test_float_return
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_float			; CHECK: callq return_float
	; CHECK: popq %rax			; CHECK: popq %rax
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%safepoint_token = tail call i32 (float (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_f32f(float () @return_float, i32 0, i32 1, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, float (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_f32f(i64 0, i32 0, float () @return_float, i32 0, i32 1, i32 0, i32 0)
	%call1 = call float @llvm.experimental.gc.result.f32(i32 %safepoint_token)			%call1 = call float @llvm.experimental.gc.result.f32(i32 %safepoint_token)
	ret float %call1			ret float %call1
	}			}

	define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" {			define i1 @test_relocate(i32 addrspace(1)* %a) gc "statepoint-example" {
	; CHECK-LABEL: test_relocate			; CHECK-LABEL: test_relocate
	; Check that an ununsed relocate has no code-generation impact			; Check that an ununsed relocate has no code-generation impact
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK-NEXT: .Ltmp9:			; CHECK-NEXT: .Ltmp9:
	; CHECK-NEXT: popq %rdx			; CHECK-NEXT: popq %rdx
	; CHECK-NEXT: retq			; CHECK-NEXT: retq
	entry:			entry:
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 1, i32 0, i32 0, i32 addrspace(1)* %a)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 1, i32 0, i32 0, i32 addrspace(1)* %a)
	%call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%call1 = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%call2 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call2 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	ret i1 %call2			ret i1 %call2
	}			}

	define void @test_void_vararg() gc "statepoint-example" {			define void @test_void_vararg() gc "statepoint-example" {
	; CHECK-LABEL: test_void_vararg			; CHECK-LABEL: test_void_vararg
	; Check a statepoint wrapping a void returning vararg function works			; Check a statepoint wrapping a void returning vararg function works
	; CHECK: callq varargf			; CHECK: callq varargf
	entry:			entry:
	%safepoint_token = tail call i32 (void (i32, ...), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(void (i32, ...) @varargf, i32 2, i32 1, i32 42, i32 43, i32 0, i32 0)			%safepoint_token = tail call i32 (i64, i32, void (i32, ...), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(i64 0, i32 0, void (i32, ...) @varargf, i32 2, i32 1, i32 42, i32 43, i32 0, i32 0)
	;; if we try to use the result from a statepoint wrapping a			;; if we try to use the result from a statepoint wrapping a
	;; non-void-returning varargf, we will experience a crash.			;; non-void-returning varargf, we will experience a crash.
	ret void			ret void
	}			}

	define i32 @test_transition_args() gc "statepoint-example" {			define i32 @test_transition_args() gc "statepoint-example" {
	; CHECK-LABEL: test_transition_args			; CHECK-LABEL: test_transition_args
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32			; CHECK: callq return_i32
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%val = alloca i32			%val = alloca i32
	%safepoint_token = call i32 (i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i32 () @return_i32, i32 0, i32 1, i32 2, i32* %val, i64 42, i32 0)			%safepoint_token = call i32 (i64, i32, i32 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32f(i64 0, i32 0, i32 () @return_i32, i32 0, i32 1, i32 2, i32* %val, i64 42, i32 0)
	%call1 = call i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)			%call1 = call i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)
	ret i32 %call1			ret i32 %call1
	}			}

	define i32 @test_transition_args_2() gc "statepoint-example" {			define i32 @test_transition_args_2() gc "statepoint-example" {
	; CHECK-LABEL: test_transition_args_2			; CHECK-LABEL: test_transition_args_2
	; CHECK: pushq %rax			; CHECK: pushq %rax
	; CHECK: callq return_i32			; CHECK: callq return_i32
	; CHECK: popq %rdx			; CHECK: popq %rdx
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%val = alloca i32			%val = alloca i32
	%arg = alloca i8			%arg = alloca i8
	%safepoint_token = call i32 (i32 (i32, i8), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32i32p0i8f(i32 (i32, i8) @return_i32_with_args, i32 2, i32 1, i32 0, i8* %arg, i32 2, i32* %val, i64 42, i32 0)			%safepoint_token = call i32 (i64, i32, i32 (i32, i8), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32i32p0i8f(i64 0, i32 0, i32 (i32, i8) @return_i32_with_args, i32 2, i32 1, i32 0, i8* %arg, i32 2, i32* %val, i64 42, i32 0)
	%call1 = call i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)			%call1 = call i32 @llvm.experimental.gc.result.i32(i32 %safepoint_token)
	ret i32 %call1			ret i32 %call1
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i1 @llvm.experimental.gc.result.i1(i32)			declare i1 @llvm.experimental.gc.result.i1(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_i32f(i32 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i32f(i64, i32, i32 ()*, i32, i32, ...)
	declare i32 @llvm.experimental.gc.statepoint.p0f_i32i32p0i8f(i32 (i32, i8), i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i32i32p0i8f(i64, i32, i32 (i32, i8), i32, i32, ...)
	declare i32 @llvm.experimental.gc.result.i32(i32)			declare i32 @llvm.experimental.gc.result.i32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_p0i32f(i32* ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_p0i32f(i64, i32, i32* ()*, i32, i32, ...)
	declare i32* @llvm.experimental.gc.result.p0i32(i32)			declare i32* @llvm.experimental.gc.result.p0i32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_f32f(float ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_f32f(i64, i32, float ()*, i32, i32, ...)
	declare float @llvm.experimental.gc.result.f32(i32)			declare float @llvm.experimental.gc.result.f32(i32)

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(void (i32, ...)*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi32varargf(i64, i32, void (i32, ...)*, i32, i32, ...)

	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)
				No newline at end of file

llvm/trunk/test/CodeGen/X86/statepoint-invoke.ll

	; RUN: llc < %s 2>&1 \| FileCheck %s			; RUN: llc < %s 2>&1 \| FileCheck %s

	target triple = "x86_64-pc-linux-gnu"			target triple = "x86_64-pc-linux-gnu"

	declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*)			declare i64 addrspace(1)* @"some_other_call"(i64 addrspace(1)*)

	declare i32 @"personality_function"()			declare i32 @"personality_function"()

	define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj,			define i64 addrspace(1)* @test_result(i64 addrspace(1)* %obj,
	i64 addrspace(1)* %obj1)			i64 addrspace(1)* %obj1)
	gc "statepoint-example" {			gc "statepoint-example" {
	entry:			entry:
	; CHECK: .Ltmp{{[0-9]+}}:			; CHECK: .Ltmp{{[0-9]+}}:
	; CHECK: callq some_other_call			; CHECK: callq some_other_call
	; CHECK: .Ltmp{{[0-9]+}}:			; CHECK: .Ltmp{{[0-9]+}}:
	%0 = invoke i32 (i64 addrspace(1)* (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 addrspace(1)* (i64 addrspace(1)) @some_other_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)			%0 = invoke i32 (i64, i32, i64 addrspace(1)* (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 0, i32 0, i64 addrspace(1)* (i64 addrspace(1)) @some_other_call, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i64 addrspace(1)* %obj, i64 addrspace(1)* %obj1)
	to label %normal_return unwind label %exceptional_return			to label %normal_return unwind label %exceptional_return

	normal_return:			normal_return:
	; CHECK: popq			; CHECK: popq
	; CHECK: retq			; CHECK: retq
	%ret_val = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %0)			%ret_val = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %0)
	ret i64 addrspace(1)* %ret_val			ret i64 addrspace(1)* %ret_val

	exceptional_return:			exceptional_return:
	; CHECK: .Ltmp{{[0-9]+}}:			; CHECK: .Ltmp{{[0-9]+}}:
	; CHECK: popq			; CHECK: popq
	; CHECK: retq			; CHECK: retq
	%landing_pad = landingpad { i8, i32 } personality i32 () @personality_function			%landing_pad = landingpad { i8, i32 } personality i32 () @personality_function
	cleanup			cleanup
	ret i64 addrspace(1)* %obj			ret i64 addrspace(1)* %obj
	}			}
	; CHECK-LABEL: GCC_except_table{{[0-9]+}}:			; CHECK-LABEL: GCC_except_table{{[0-9]+}}:
	; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}			; CHECK: .long .Ltmp{{[0-9]+}}-.Ltmp{{[0-9]+}}
	; CHECK: .long .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}			; CHECK: .long .Ltmp{{[0-9]+}}-.Lfunc_begin{{[0-9]+}}
	; CHECK: .byte 0			; CHECK: .byte 0
	; CHECK: .align 4			; CHECK: .align 4

	declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64 addrspace(1)* (i64 addrspace(1)), i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64p1i64f(i64, i32, i64 addrspace(1)* (i64 addrspace(1)), i32, i32, ...)
	declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32)			declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32)
				No newline at end of file

llvm/trunk/test/CodeGen/X86/statepoint-stack-usage.ll

	; RUN: llc < %s \| FileCheck %s			; RUN: llc < %s \| FileCheck %s

	target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"			target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-pc-linux-gnu"			target triple = "x86_64-pc-linux-gnu"

	; This test is checking to make sure that we reuse the same stack slots			; This test is checking to make sure that we reuse the same stack slots
	; for GC values spilled over two different call sites. Since the order			; for GC values spilled over two different call sites. Since the order
	; of GC arguments differ, niave lowering code would insert loads and			; of GC arguments differ, niave lowering code would insert loads and
	; stores to rearrange items on the stack. We need to make sure (for			; stores to rearrange items on the stack. We need to make sure (for
	; performance) that this doesn't happen.			; performance) that this doesn't happen.
	define i32 @back_to_back_calls(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" {			define i32 @back_to_back_calls(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" {
	; CHECK-LABEL: back_to_back_calls			; CHECK-LABEL: back_to_back_calls
	; The exact stores don't matter, but there need to be three stack slots created			; The exact stores don't matter, but there need to be three stack slots created
	; CHECK: movq %rdi, 16(%rsp)			; CHECK: movq %rdi, 16(%rsp)
	; CHECK: movq %rdx, 8(%rsp)			; CHECK: movq %rdx, 8(%rsp)
	; CHECK: movq %rsi, (%rsp)			; CHECK: movq %rsi, (%rsp)
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c)
	%a1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 10)			%a1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 12)
	%b1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 11)			%b1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 13)
	%c1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 12)			%c1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 14)
	; CHECK: callq			; CHECK: callq
	; This is the key check. There should NOT be any memory moves here			; This is the key check. There should NOT be any memory moves here
	; CHECK-NOT: movq			; CHECK-NOT: movq
	%safepoint_token2 = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %c1, i32 addrspace(1)* %b1, i32 addrspace(1)* %a1)			%safepoint_token2 = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %c1, i32 addrspace(1)* %b1, i32 addrspace(1)* %a1)
	%a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 12)			%a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 14)
	%b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 11)			%b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 13)
	%c2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 10)			%c2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 12)
	; CHECK: callq			; CHECK: callq
	ret i32 1			ret i32 1
	}			}

	; This test simply checks that minor changes in vm state don't prevent slots			; This test simply checks that minor changes in vm state don't prevent slots
	; being reused for gc values.			; being reused for gc values.
	define i32 @reserve_first(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" {			define i32 @reserve_first(i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c) #1 gc "statepoint-example" {
	; CHECK-LABEL: reserve_first			; CHECK-LABEL: reserve_first
	; The exact stores don't matter, but there need to be three stack slots created			; The exact stores don't matter, but there need to be three stack slots created
	; CHECK: movq %rdi, 16(%rsp)			; CHECK: movq %rdi, 16(%rsp)
	; CHECK: movq %rdx, 8(%rsp)			; CHECK: movq %rdx, 8(%rsp)
	; CHECK: movq %rsi, (%rsp)			; CHECK: movq %rsi, (%rsp)
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i32 addrspace(1)* %a, i32 addrspace(1)* %b, i32 addrspace(1)* %c)
	%a1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 10)			%a1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 12)
	%b1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 11)			%b1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 13)
	%c1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 10, i32 12)			%c1 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 12, i32 14)
	; CHECK: callq			; CHECK: callq
	; This is the key check. There should NOT be any memory moves here			; This is the key check. There should NOT be any memory moves here
	; CHECK-NOT: movq			; CHECK-NOT: movq
	%safepoint_token2 = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 addrspace(1)* %a1, i32 0, i32 addrspace(1)* %c1, i32 0, i32 0, i32 addrspace(1)* %c1, i32 addrspace(1)* %b1, i32 addrspace(1)* %a1)			%safepoint_token2 = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 addrspace(1)* %a1, i32 0, i32 addrspace(1)* %c1, i32 0, i32 0, i32 addrspace(1)* %c1, i32 addrspace(1)* %b1, i32 addrspace(1)* %a1)
	%a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 12)			%a2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 14)
	%b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 11)			%b2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 13)
	%c2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 10, i32 10)			%c2 = tail call coldcc i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token2, i32 12, i32 12)
	; CHECK: callq			; CHECK: callq
	ret i32 1			ret i32 1
	}			}

	; Function Attrs: nounwind			; Function Attrs: nounwind
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

	attributes #1 = { uwtable }			attributes #1 = { uwtable }
				No newline at end of file

llvm/trunk/test/CodeGen/X86/statepoint-stackmap-format.ll

	Show All 18 Lines
	; CHECK: movq %rax, 8(%rsp)			; CHECK: movq %rax, 8(%rsp)
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: addq $40, %rsp			; CHECK: addq $40, %rsp
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%metadata1 = alloca i32 addrspace(1)*, i32 2, align 8			%metadata1 = alloca i32 addrspace(1)*, i32 2, align 8
	store i32 addrspace(1)* null, i32 addrspace(1)** %metadata1			store i32 addrspace(1)* null, i32 addrspace(1)** %metadata1
	%ptr_derived = getelementptr i32, i32 addrspace(1)* %ptr_base, i32 %arg			%ptr_derived = getelementptr i32, i32 addrspace(1)* %ptr_base, i32 %arg
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 2, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* null, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* %ptr_derived, i32 addrspace(1)* null)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 2, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* null, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* %ptr_derived, i32 addrspace(1)* null)
	%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	%a = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)			%a = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 9)
	%b = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 8)			%b = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 10)
	%c = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 9)			%c = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 11, i32 11)
	;			;
	ret i1 %call1			ret i1 %call1
	}			}

	; This is similar to the previous test except that we have derived pointer as			; This is similar to the previous test except that we have derived pointer as
	; argument to the function. Despite that this can not happen after the			; argument to the function. Despite that this can not happen after the
	; RewriteSafepointForGC pass, lowering should be able to handle it anyway.			; RewriteSafepointForGC pass, lowering should be able to handle it anyway.
	define i1 @test_derived_arg(i32 addrspace(1)* %ptr_base,			define i1 @test_derived_arg(i32 addrspace(1)* %ptr_base,
	i32 addrspace(1)* %ptr_derived)			i32 addrspace(1)* %ptr_derived)
	gc "statepoint-example" {			gc "statepoint-example" {
	; CHECK-LABEL: test_derived_arg			; CHECK-LABEL: test_derived_arg
	; Do we see two spills for the local values and the store to the			; Do we see two spills for the local values and the store to the
	; alloca?			; alloca?
	; CHECK: subq $40, %rsp			; CHECK: subq $40, %rsp
	; CHECK: movq $0, 24(%rsp)			; CHECK: movq $0, 24(%rsp)
	; CHECK: movq %rdi, 16(%rsp)			; CHECK: movq %rdi, 16(%rsp)
	; CHECK: movq %rsi, 8(%rsp)			; CHECK: movq %rsi, 8(%rsp)
	; CHECK: callq return_i1			; CHECK: callq return_i1
	; CHECK: addq $40, %rsp			; CHECK: addq $40, %rsp
	; CHECK: retq			; CHECK: retq
	entry:			entry:
	%metadata1 = alloca i32 addrspace(1)*, i32 2, align 8			%metadata1 = alloca i32 addrspace(1)*, i32 2, align 8
	store i32 addrspace(1)* null, i32 addrspace(1)** %metadata1			store i32 addrspace(1)* null, i32 addrspace(1)** %metadata1
	%safepoint_token = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 2, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* null, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* %ptr_derived, i32 addrspace(1)* null)			%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 2, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* null, i32 addrspace(1)* %ptr_base, i32 addrspace(1)* %ptr_derived, i32 addrspace(1)* null)
	%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)			%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
	%a = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)			%a = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 9)
	%b = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 8)			%b = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 10)
	%c = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 9, i32 9)			%c = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 11, i32 11)
	;			;
	ret i1 %call1			ret i1 %call1
	}			}

				; Simple test case to check that we emit the ID field correctly
				define i1 @test_id() gc "statepoint-example" {
				; CHECK-LABEL: test_id
				entry:
				%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 237, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0)
				%call1 = call zeroext i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
				ret i1 %call1
				}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)
				declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i1 @llvm.experimental.gc.result.i1(i32)			declare i1 @llvm.experimental.gc.result.i1(i32)
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3

	; CHECK-LABEL: .section .llvm_stackmaps			; CHECK-LABEL: .section .llvm_stackmaps
	; CHECK-NEXT: __LLVM_StackMaps:			; CHECK-NEXT: __LLVM_StackMaps:
	; Header			; Header
	; CHECK-NEXT: .byte 1			; CHECK-NEXT: .byte 1
	; CHECK-NEXT: .byte 0			; CHECK-NEXT: .byte 0
	; CHECK-NEXT: .short 0			; CHECK-NEXT: .short 0
	; Num Functions			; Num Functions
	; CHECK-NEXT: .long 2			; CHECK-NEXT: .long 3
	; Num LargeConstants			; Num LargeConstants
	; CHECK-NEXT: .long 0			; CHECK-NEXT: .long 0
	; Num Callsites			; Num Callsites
	; CHECK-NEXT: .long 2			; CHECK-NEXT: .long 3

	; Functions and stack size			; Functions and stack size
	; CHECK-NEXT: .quad test			; CHECK-NEXT: .quad test
	; CHECK-NEXT: .quad 40			; CHECK-NEXT: .quad 40
	; CHECK-NEXT: .quad test_derived_arg			; CHECK-NEXT: .quad test_derived_arg
	; CHECK-NEXT: .quad 40			; CHECK-NEXT: .quad 40

	;			;
	; test			; test
	;			;

	; Large Constants			; Large Constants
	; Statepoint ID only			; Statepoint ID only
	; CHECK: .quad 2882400000			; CHECK: .quad 0

	; Callsites			; Callsites
	; Constant arguments			; Constant arguments
	; CHECK: .long .Ltmp1-test			; CHECK: .long .Ltmp1-test
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .short 11			; CHECK: .short 11
	; SmallConstant (0)			; SmallConstant (0)
	; CHECK: .byte 4			; CHECK: .byte 4
	▲ Show 20 Lines • Show All 57 Lines • ▼ Show 20 Lines
	; CHECK: .align 8			; CHECK: .align 8

	;			;
	; test_derived_arg			; test_derived_arg
	;			;

	; Large Constants			; Large Constants
	; Statepoint ID only			; Statepoint ID only
	; CHECK: .quad 2882400000			; CHECK: .quad 0

	; Callsites			; Callsites
	; Constant arguments			; Constant arguments
	; CHECK: .long .Ltmp3-test_derived_arg			; CHECK: .long .Ltmp3-test_derived_arg
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .short 11			; CHECK: .short 11
	; SmallConstant (0)			; SmallConstant (0)
	; CHECK: .byte 4			; CHECK: .byte 4
	▲ Show 20 Lines • Show All 45 Lines • ▼ Show 20 Lines
	; CHECK: .byte 8			; CHECK: .byte 8
	; CHECK: .short 7			; CHECK: .short 7
	; CHECK: .long 16			; CHECK: .long 16

	; No Padding or LiveOuts			; No Padding or LiveOuts
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .short 0			; CHECK: .short 0
	; CHECK: .align 8			; CHECK: .align 8

				; Records for the test_id function:
				; No large constants

				; The Statepoint ID:
				; CHECK: .quad 237

				; Instruction Offset
				; CHECK: .long .Ltmp5-test_id

				; Reserved:
				; CHECK: .short 0

				; NumLocations:
				; CHECK: .short 3

				; StkMapRecord[0]:
				; SmallConstant(0):
				; CHECK: .byte 4
				; CHECK: .byte 8
				; CHECK: .short 0
				; CHECK: .long 0

				; StkMapRecord[1]:
				; SmallConstant(0):
				; CHECK: .byte 4
				; CHECK: .byte 8
				; CHECK: .short 0
				; CHECK: .long 0

				; StkMapRecord[2]:
				; SmallConstant(0):
				; CHECK: .byte 4
				; CHECK: .byte 8
				; CHECK: .short 0
				; CHECK: .long 0

				; No padding or LiveOuts
				; CHECK: .short 0
				; CHECK: .short 0
				; CHECK: .align 8

llvm/trunk/test/Transforms/CodeGenPrepare/statepoint-relocate.ll

	; RUN: opt -codegenprepare -S < %s \| FileCheck %s			; RUN: opt -codegenprepare -S < %s \| FileCheck %s

	target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"			target datalayout = "e-i64:64-f80:128-n8:16:32:64-S128"
	target triple = "x86_64-pc-linux-gnu"			target triple = "x86_64-pc-linux-gnu"

	declare zeroext i1 @return_i1()			declare zeroext i1 @return_i1()

	define i32 @test_sor_basic(i32* %base) gc "statepoint-example" {			define i32 @test_sor_basic(i32* %base) gc "statepoint-example" {
	; CHECK: getelementptr i32, i32* %base, i32 15			; CHECK: getelementptr i32, i32* %base, i32 15
	; CHECK: getelementptr i32, i32* %base-new, i32 15			; CHECK: getelementptr i32, i32* %base-new, i32 15
	entry:			entry:
	%ptr = getelementptr i32, i32* %base, i32 15			%ptr = getelementptr i32, i32* %base, i32 15
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr)
	%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 5)			%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 7)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	define i32 @test_sor_two_derived(i32* %base) gc "statepoint-example" {			define i32 @test_sor_two_derived(i32* %base) gc "statepoint-example" {
	; CHECK: getelementptr i32, i32* %base, i32 15			; CHECK: getelementptr i32, i32* %base, i32 15
	; CHECK: getelementptr i32, i32* %base, i32 12			; CHECK: getelementptr i32, i32* %base, i32 12
	; CHECK: getelementptr i32, i32* %base-new, i32 12			; CHECK: getelementptr i32, i32* %base-new, i32 12
	; CHECK: getelementptr i32, i32* %base-new, i32 15			; CHECK: getelementptr i32, i32* %base-new, i32 15
	entry:			entry:
	%ptr = getelementptr i32, i32* %base, i32 15			%ptr = getelementptr i32, i32* %base, i32 15
	%ptr2 = getelementptr i32, i32* %base, i32 12			%ptr2 = getelementptr i32, i32* %base, i32 12
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr, i32* %ptr2)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr, i32* %ptr2)
	%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 5)			%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 7)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%ptr2-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 7)			%ptr2-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 9)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	define i32 @test_sor_ooo(i32* %base) gc "statepoint-example" {			define i32 @test_sor_ooo(i32* %base) gc "statepoint-example" {
	; CHECK: getelementptr i32, i32* %base, i32 15			; CHECK: getelementptr i32, i32* %base, i32 15
	; CHECK: getelementptr i32, i32* %base-new, i32 15			; CHECK: getelementptr i32, i32* %base-new, i32 15
	entry:			entry:
	%ptr = getelementptr i32, i32* %base, i32 15			%ptr = getelementptr i32, i32* %base, i32 15
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 5)			%base-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 7)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	define i32 @test_sor_gep_smallint([3 x i32]* %base) gc "statepoint-example" {			define i32 @test_sor_gep_smallint([3 x i32]* %base) gc "statepoint-example" {
	; CHECK: getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 2			; CHECK: getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 2
	; CHECK: getelementptr [3 x i32], [3 x i32]* %base-new, i32 0, i32 2			; CHECK: getelementptr [3 x i32], [3 x i32]* %base-new, i32 0, i32 2
	entry:			entry:
	%ptr = getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 2			%ptr = getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 2
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %base, i32* %ptr)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %base, i32* %ptr)
	%base-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 5, i32 5)			%base-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 7, i32 7)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	define i32 @test_sor_gep_largeint([3 x i32]* %base) gc "statepoint-example" {			define i32 @test_sor_gep_largeint([3 x i32]* %base) gc "statepoint-example" {
	; CHECK: getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 21			; CHECK: getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 21
	; CHECK-NOT: getelementptr [3 x i32], [3 x i32]* %base-new, i32 0, i32 21			; CHECK-NOT: getelementptr [3 x i32], [3 x i32]* %base-new, i32 0, i32 21
	entry:			entry:
	%ptr = getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 21			%ptr = getelementptr [3 x i32], [3 x i32]* %base, i32 0, i32 21
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %base, i32* %ptr)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, [3 x i32]* %base, i32* %ptr)
	%base-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 5, i32 5)			%base-new = call [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32 %tok, i32 7, i32 7)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	define i32 @test_sor_noop(i32* %base) gc "statepoint-example" {			define i32 @test_sor_noop(i32* %base) gc "statepoint-example" {
	; CHECK: getelementptr i32, i32* %base, i32 15			; CHECK: getelementptr i32, i32* %base, i32 15
	; CHECK: call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			; CHECK: call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	; CHECK: call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 7)			; CHECK: call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 9)
	entry:			entry:
	%ptr = getelementptr i32, i32* %base, i32 15			%ptr = getelementptr i32, i32* %base, i32 15
	%ptr2 = getelementptr i32, i32* %base, i32 12			%ptr2 = getelementptr i32, i32* %base, i32 12
	%tok = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr, i32* %ptr2)			%tok = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32* %base, i32* %ptr, i32* %ptr2)
	%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 6)			%ptr-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 8)
	%ptr2-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 5, i32 7)			%ptr2-new = call i32* @llvm.experimental.gc.relocate.p0i32(i32 %tok, i32 7, i32 9)
	%ret = load i32, i32* %ptr-new			%ret = load i32, i32* %ptr-new
	ret i32 %ret			ret i32 %ret
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i32* @llvm.experimental.gc.relocate.p0i32(i32, i32, i32)			declare i32* @llvm.experimental.gc.relocate.p0i32(i32, i32, i32)
	declare [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32, i32, i32)			declare [3 x i32]* @llvm.experimental.gc.relocate.p0a3i32(i32, i32, i32)

llvm/trunk/test/Transforms/InstCombine/gc.relocate.ll

	; RUN: opt < %s -instcombine -S \| FileCheck %s			; RUN: opt < %s -instcombine -S \| FileCheck %s
	target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"			target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128"

	; Uses InstCombine with DataLayout to propagate dereferenceable			; Uses InstCombine with DataLayout to propagate dereferenceable
	; attribute via gc.relocate: if the derived ptr is dereferenceable(N),			; attribute via gc.relocate: if the derived ptr is dereferenceable(N),
	; then the return attribute of gc.relocate is dereferenceable(N).			; then the return attribute of gc.relocate is dereferenceable(N).

	declare zeroext i1 @return_i1()			declare zeroext i1 @return_i1()
	declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i1 ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32)

	define i32 addrspace(1)* @deref(i32 addrspace(1)* dereferenceable(8) %dparam) gc "statepoint-example" {			define i32 addrspace(1)* @deref(i32 addrspace(1)* dereferenceable(8) %dparam) gc "statepoint-example" {
	; Checks that a dereferenceabler pointer			; Checks that a dereferenceabler pointer
	; CHECK-LABEL: @deref			; CHECK-LABEL: @deref
	; CHECK: call dereferenceable(8)			; CHECK: call dereferenceable(8)
	entry:			entry:
	%load = load i32, i32 addrspace(1)* %dparam			%load = load i32, i32 addrspace(1)* %dparam
	%tok = tail call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)			%tok = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 0, i1 () @return_i1, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %dparam)
	%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %tok, i32 5, i32 5)			%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %tok, i32 7, i32 7)
	ret i32 addrspace(1)* %relocate			ret i32 addrspace(1)* %relocate
	}			}

llvm/trunk/test/Transforms/InstCombine/statepoint.ll

	; RUN: opt < %s -instcombine -S \| FileCheck %s			; RUN: opt < %s -instcombine -S \| FileCheck %s
	; These tests check the optimizations specific to			; These tests check the optimizations specific to
	; pointers being relocated at a statepoint.			; pointers being relocated at a statepoint.


	declare void @func()			declare void @func()

	define i1 @test_negative(i32 addrspace(1)* %p) gc "statepoint-example" {			define i1 @test_negative(i32 addrspace(1)* %p) gc "statepoint-example" {
	entry:			entry:
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %p)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %p)
	%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%cmp = icmp eq i32 addrspace(1)* %pnew, null			%cmp = icmp eq i32 addrspace(1)* %pnew, null
	ret i1 %cmp			ret i1 %cmp
	; CHECK-LABEL: test_negative			; CHECK-LABEL: test_negative
	; CHECK: %pnew = call i32 addrspace(1)*			; CHECK: %pnew = call i32 addrspace(1)*
	; CHECK: ret i1 %cmp			; CHECK: ret i1 %cmp
	}			}

	define i1 @test_nonnull(i32 addrspace(1)* nonnull %p) gc "statepoint-example" {			define i1 @test_nonnull(i32 addrspace(1)* nonnull %p) gc "statepoint-example" {
	entry:			entry:
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %p)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* %p)
	%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%cmp = icmp eq i32 addrspace(1)* %pnew, null			%cmp = icmp eq i32 addrspace(1)* %pnew, null
	ret i1 %cmp			ret i1 %cmp
	; CHECK-LABEL: test_nonnull			; CHECK-LABEL: test_nonnull
	; CHECK: ret i1 false			; CHECK: ret i1 false
	}			}

	define i1 @test_null() gc "statepoint-example" {			define i1 @test_null() gc "statepoint-example" {
	entry:			entry:
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* null)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* null)
	%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%cmp = icmp eq i32 addrspace(1)* %pnew, null			%cmp = icmp eq i32 addrspace(1)* %pnew, null
	ret i1 %cmp			ret i1 %cmp
	; CHECK-LABEL: test_null			; CHECK-LABEL: test_null
	; CHECK-NOT: %pnew			; CHECK-NOT: %pnew
	; CHECK: ret i1 true			; CHECK: ret i1 true
	}			}

	define i1 @test_undef() gc "statepoint-example" {			define i1 @test_undef() gc "statepoint-example" {
	entry:			entry:
	%safepoint_token = tail call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* undef)			%safepoint_token = tail call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @func, i32 0, i32 0, i32 0, i32 0, i32 addrspace(1)* undef)
	%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 5, i32 5)			%pnew = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %safepoint_token, i32 7, i32 7)
	%cmp = icmp eq i32 addrspace(1)* %pnew, null			%cmp = icmp eq i32 addrspace(1)* %pnew, null
	ret i1 %cmp			ret i1 %cmp
	; CHECK-LABEL: test_undef			; CHECK-LABEL: test_undef
	; CHECK-NOT: %pnew			; CHECK-NOT: %pnew
	; CHECK: ret i1 undef			; CHECK: ret i1 undef
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #3

llvm/trunk/test/Transforms/PlaceSafepoints/basic.ll

	Show First 20 Lines • Show All 67 Lines • ▼ Show 20 Lines
	declare zeroext i1 @i1_return_i1(i1)			declare zeroext i1 @i1_return_i1(i1)

	define i1 @test_call_with_result() gc "statepoint-example" {			define i1 @test_call_with_result() gc "statepoint-example" {
	; CHECK-LABEL: test_call_with_result			; CHECK-LABEL: test_call_with_result
	; This is checking that a statepoint_poll + statepoint + result is			; This is checking that a statepoint_poll + statepoint + result is
	; inserted for a function that takes 1 argument.			; inserted for a function that takes 1 argument.
	; CHECK: gc.statepoint.p0f_isVoidf			; CHECK: gc.statepoint.p0f_isVoidf
	; CHECK: gc.statepoint.p0f_i1i1f			; CHECK: gc.statepoint.p0f_i1i1f
	; CHECK: (i1 (i1)* @i1_return_i1, i32 1, i32 0, i1 false, i32 0, i32 0)			; CHECK: (i64 2882400000, i32 0, i1 (i1)* @i1_return_i1, i32 1, i32 0, i1 false, i32 0, i32 0)
	; CHECK: %call1.2 = call i1 @llvm.experimental.gc.result.i1			; CHECK: %call1.2 = call i1 @llvm.experimental.gc.result.i1
	entry:			entry:
	%call1 = tail call i1 (i1) @i1_return_i1(i1 false)			%call1 = tail call i1 (i1) @i1_return_i1(i1 false)
	ret i1 %call1			ret i1 %call1
	}			}

	; This function is inlined when inserting a poll. To avoid recursive			; This function is inlined when inserting a poll. To avoid recursive
	; issues, make sure we don't place safepoints in it.			; issues, make sure we don't place safepoints in it.
	Show All 10 Lines

llvm/trunk/test/Transforms/PlaceSafepoints/call-in-loop.ll

	Show All 9 Lines

	entry:			entry:
	; CHECK-LABEL: entry			; CHECK-LABEL: entry
	; CHECK: statepoint			; CHECK: statepoint
	br label %loop			br label %loop

	loop:			loop:
	; CHECK-LABEL: loop			; CHECK-LABEL: loop
	; CHECK: @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()* @foo			; CHECK: @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 2882400000, i32 0, void ()* @foo
	; CHECK-NOT: statepoint			; CHECK-NOT: statepoint
	call void @foo()			call void @foo()
	br label %loop			br label %loop
	}			}

	; This function is inlined when inserting a poll.			; This function is inlined when inserting a poll.
	declare void @do_safepoint()			declare void @do_safepoint()
	define void @gc.safepoint_poll() {			define void @gc.safepoint_poll() {
	; CHECK-LABEL: gc.safepoint_poll			; CHECK-LABEL: gc.safepoint_poll
	entry:			entry:
	call void @do_safepoint()			call void @do_safepoint()
	ret void			ret void
	}			}

llvm/trunk/test/Transforms/PlaceSafepoints/finite-loops.ll

	Show First 20 Lines • Show All 71 Lines • ▼ Show 20 Lines

	; This function is inlined when inserting a poll.			; This function is inlined when inserting a poll.
	declare void @do_safepoint()			declare void @do_safepoint()
	define void @gc.safepoint_poll() {			define void @gc.safepoint_poll() {
	; CHECK-LABEL: gc.safepoint_poll			; CHECK-LABEL: gc.safepoint_poll
	entry:			entry:
	call void @do_safepoint()			call void @do_safepoint()
	ret void			ret void
	}			}
				No newline at end of file

llvm/trunk/test/Transforms/PlaceSafepoints/invokes.ll

	Show First 20 Lines • Show All 102 Lines • ▼ Show 20 Lines
	define void @gc.safepoint_poll() {			define void @gc.safepoint_poll() {
	; CHECK-LABEL: gc.safepoint_poll			; CHECK-LABEL: gc.safepoint_poll
	; CHECK-LABEL: entry			; CHECK-LABEL: entry
	; CHECK-NEXT: do_safepoint			; CHECK-NEXT: do_safepoint
	; CHECK-NEXT: ret void			; CHECK-NEXT: ret void
	entry:			entry:
	call void @do_safepoint()			call void @do_safepoint()
	ret void			ret void
	}			}
				No newline at end of file

llvm/trunk/test/Transforms/PlaceSafepoints/split-backedge.ll

Show All 37 Lines	loop2:
br i1 %cond, label %loop, label %loop2		br i1 %cond, label %loop, label %loop2
}		}

declare void @do_safepoint()		declare void @do_safepoint()
define void @gc.safepoint_poll() {		define void @gc.safepoint_poll() {
entry:		entry:
call void @do_safepoint()		call void @do_safepoint()
ret void		ret void
}		}
		No newline at end of file

llvm/trunk/test/Transforms/PlaceSafepoints/statepoint-frameescape.ll

	Show All 20 Lines
	define void @gc.safepoint_poll() {			define void @gc.safepoint_poll() {
	; CHECK-LABEL: gc.safepoint_poll			; CHECK-LABEL: gc.safepoint_poll
	; CHECK-LABEL: entry			; CHECK-LABEL: entry
	; CHECK-NEXT: do_safepoint			; CHECK-NEXT: do_safepoint
	; CHECK-NEXT: ret void			; CHECK-NEXT: ret void
	entry:			entry:
	call void @do_safepoint()			call void @do_safepoint()
	ret void			ret void
	}			}
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll

	Show All 14 Lines
	there:			there:
	%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1			%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
	br label %merge			br label %merge

	merge:			merge:
	; CHECK-LABEL: merge:			; CHECK-LABEL: merge:
	; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %here ], [ %base_obj_y, %there ]			; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %here ], [ %base_obj_y, %there ]
	%merged_value = phi i64 addrspace(1)* [ %x, %here ], [ %y, %there ]			%merged_value = phi i64 addrspace(1)* [ %x, %here ], [ %y, %there ]
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i64 addrspace(1)* %merged_value			ret i64 addrspace(1)* %merged_value
	}			}

	declare void @foo()			declare void @foo()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll

	Show All 24 Lines
	true:			true:
	br label %merge			br label %merge

	false:			false:
	br label %merge			br label %merge

	merge:			merge:
	%next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ]			%next = phi i64 addrspace(1)* [ %next_x, %true ], [ %next_y, %false ]
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop			br label %loop
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll

	Show All 13 Lines
	; CHECK: phi i64 addrspace(1)*			; CHECK: phi i64 addrspace(1)*
	; CHECK-DAG: [ %base_obj.relocated.casted, %loop ]			; CHECK-DAG: [ %base_obj.relocated.casted, %loop ]
	; CHECK-DAG: [ %base_obj, %entry ]			; CHECK-DAG: [ %base_obj, %entry ]
	; CHECK: %current = phi i64 addrspace(1)*			; CHECK: %current = phi i64 addrspace(1)*
	; CHECK-DAG: [ %obj, %entry ]			; CHECK-DAG: [ %obj, %entry ]
	; CHECK-DAG: [ %next.relocated.casted, %loop ]			; CHECK-DAG: [ %next.relocated.casted, %loop ]
	%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]			%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]
	%next = getelementptr i64, i64 addrspace(1)* %current, i32 1			%next = getelementptr i64, i64 addrspace(1)* %current, i32 1
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop			br label %loop
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll

	; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s

	; CHECK: derived %merged_value base %base_obj			; CHECK: derived %merged_value base %base_obj


	define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" {			define i64 addrspace(1)* @test(i64 addrspace(1)* %base_obj, i1 %runtime_condition) gc "statepoint-example" {
	entry:			entry:
	br i1 %runtime_condition, label %merge, label %there			br i1 %runtime_condition, label %merge, label %there

	there:			there:
	%derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1			%derived_obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
	br label %merge			br label %merge

	merge:			merge:
	%merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ]			%merged_value = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %derived_obj, %there ]
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i64 addrspace(1)* %merged_value			ret i64 addrspace(1)* %merged_value
	}			}

	declare void @foo()			declare void @foo()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll

	; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s

	; CHECK: derived %next.i64 base %base_obj			; CHECK: derived %next.i64 base %base_obj

	define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {			define void @test(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
	entry:			entry:
	%obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1			%obj = getelementptr i64, i64 addrspace(1)* %base_obj, i32 1
	br label %loop			br label %loop

	loop:			loop:
	%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next.i64, %loop ]			%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next.i64, %loop ]
	%current.i32 = bitcast i64 addrspace(1)* %current to i32 addrspace(1)*			%current.i32 = bitcast i64 addrspace(1)* %current to i32 addrspace(1)*
	%next.i32 = getelementptr i32, i32 addrspace(1)* %current.i32, i32 1			%next.i32 = getelementptr i32, i32 addrspace(1)* %current.i32, i32 1
	%next.i64 = bitcast i32 addrspace(1)* %next.i32 to i64 addrspace(1)*			%next.i64 = bitcast i32 addrspace(1)* %next.i32 to i64 addrspace(1)*
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop			br label %loop
	}			}

	declare void @do_safepoint()			declare void @do_safepoint()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll

	; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s


	; CHECK: derived %obj_to_consume base %base_phi			; CHECK: derived %obj_to_consume base %base_phi

	declare void @foo()			declare void @foo()
	declare i64 addrspace(1)* @generate_obj()			declare i64 addrspace(1)* @generate_obj()
	declare void @consume_obj(i64 addrspace(1)*)			declare void @consume_obj(i64 addrspace(1)*)

	define void @test(i32 %condition) gc "statepoint-example" {			define void @test(i32 %condition) gc "statepoint-example" {
	entry:			entry:
	br label %loop			br label %loop

	loop:			loop:
	; CHECK: loop:			; CHECK: loop:
	; CHECK: %safepoint_token1 = call i32 (i64 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 addrspace(1) ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i3			; CHECK: %safepoint_token1 = call i32 (i64, i32, i64 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 0, i32 0, i64 addrspace(1) ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i3
	; CHECK-NEXT: %obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result			; CHECK-NEXT: %obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result
	%safepoint_token1 = call i32 (i64 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 addrspace(1) ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token1 = call i32 (i64, i32, i64 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 0, i32 0, i64 addrspace(1) ()* @generate_obj, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	%obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %safepoint_token1)			%obj2 = call i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32 %safepoint_token1)
	switch i32 %condition, label %dest_a [			switch i32 %condition, label %dest_a [
	i32 0, label %dest_b			i32 0, label %dest_b
	i32 1, label %dest_c			i32 1, label %dest_c
	]			]

	dest_a:			dest_a:
	br label %merge			br label %merge

	dest_b:			dest_b:
	br label %merge			br label %merge

	dest_c:			dest_c:
	br label %merge			br label %merge

	merge:			merge:
	; CHECK: merge:			; CHECK: merge:
	; CHECK: %base_phi = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]			; CHECK: %base_phi = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
	; CHECK: %obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]			; CHECK: %obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]

	%obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]			%obj_to_consume = phi i64 addrspace(1)* [ %obj2, %dest_a ], [ null, %dest_b ], [ null, %dest_c ]
	%safepoint_token3 = call i32 (void (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(void (i64 addrspace(1)) @consume_obj, i32 1, i32 0, i64 addrspace(1)* %obj_to_consume, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token3 = call i32 (i64, i32, void (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)) @consume_obj, i32 1, i32 0, i64 addrspace(1)* %obj_to_consume, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %merge.split			br label %merge.split

	merge.split: ; preds = %merge			merge.split: ; preds = %merge
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop			br label %loop
	}			}


	; Function Attrs: nounwind			; Function Attrs: nounwind
	declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32) #0			declare i64 addrspace(1)* @llvm.experimental.gc.result.p1i64(i32) #0
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
	declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64f(i64 addrspace(1)* ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_p1i64f(i64, i32, i64 addrspace(1)* ()*, i32, i32, ...)
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(void (i64 addrspace(1)), i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)), i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll

Show All 17 Lines	there:
%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1		%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
br label %merge		br label %merge

merge:		merge:
; CHECK: merge:		; CHECK: merge:
; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %base_obj_y, %there ]		; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %base_obj_y, %there ]
; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ]		; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ]
%merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ]		%merged_value = phi i64 addrspace(1)* [ %base_obj_x, %bump ], [ %y, %there ]
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
ret i64 addrspace(1)* %merged_value		ret i64 addrspace(1)* %merged_value
}		}

declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll

Show All 27 Lines	there:
%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1		%y = getelementptr i64, i64 addrspace(1)* %base_obj_y, i32 1
br label %merge		br label %merge

merge:		merge:
; CHECK: merge:		; CHECK: merge:
; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %merge_here ], [ %base_obj_y, %there ]		; CHECK: %base_phi = phi i64 addrspace(1)* [ %base_obj_x, %merge_here ], [ %base_obj_y, %there ]
; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]		; CHECK-NEXT: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]
%merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]		%merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
ret i64 addrspace(1)* %merged_value		ret i64 addrspace(1)* %merged_value
}		}

declare void @do_safepoint()		declare void @do_safepoint()
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
		No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll

	Show All 38 Lines
	; CHECK: merge:			; CHECK: merge:
	; CHECK-DAG: %base_phi1			; CHECK-DAG: %base_phi1
	; CHECK-DAG: phi i64 addrspace(1)*			; CHECK-DAG: phi i64 addrspace(1)*
	; CHECK-DAG: %merge_here			; CHECK-DAG: %merge_here
	; CHECK-DAG: [ %base_obj_y, %there ]			; CHECK-DAG: [ %base_obj_y, %there ]
	; CHECK: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]			; CHECK: %merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]
	%merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]			%merged_value = phi i64 addrspace(1)* [ %x, %merge_here ], [ %y, %there ]

	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @site_for_call_safpeoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i64 addrspace(1)* %merged_value			ret i64 addrspace(1)* %merged_value
	}			}

	declare void @do_safepoint()			declare void @do_safepoint()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll

	Show All 18 Lines
	check_for_null:			check_for_null:
	%current_element = load i64 addrspace(1), i64 addrspace(1) addrspace(1)* %current_element_ptr			%current_element = load i64 addrspace(1), i64 addrspace(1) addrspace(1)* %current_element_ptr
	%is_null = icmp eq i64 addrspace(1)* %current_element, null			%is_null = icmp eq i64 addrspace(1)* %current_element, null
	br i1 %is_null, label %found, label %loop_back			br i1 %is_null, label %found, label %loop_back

	loop_back:			loop_back:
	%next_element_ptr = getelementptr i64 addrspace(1), i64 addrspace(1) addrspace(1)* %current_element_ptr, i32 1			%next_element_ptr = getelementptr i64 addrspace(1), i64 addrspace(1) addrspace(1)* %current_element_ptr, i32 1
	%next_index = add i32 %index, 1			%next_index = add i32 %index, 1
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop_check			br label %loop_check

	not_found:			not_found:
	ret i32 -1			ret i32 -1

	found:			found:
	ret i32 %index			ret i32 %index
	}			}

	declare void @do_safepoint()			declare void @do_safepoint()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll

	; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -spp-print-base-pointers -S 2>&1 \| FileCheck %s

	; CHECK: derived %next base %base_obj			; CHECK: derived %next base %base_obj

	declare i1 @runtime_value()			declare i1 @runtime_value()

	define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {			define void @maybe_GEP(i64 addrspace(1)* %base_obj) gc "statepoint-example" {
	entry:			entry:
	br label %loop			br label %loop

	loop:			loop:
	%current = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %next, %loop ]			%current = phi i64 addrspace(1)* [ %base_obj, %entry ], [ %next, %loop ]
	%condition = call i1 @runtime_value()			%condition = call i1 @runtime_value()
	%maybe_next = getelementptr i64, i64 addrspace(1)* %current, i32 1			%maybe_next = getelementptr i64, i64 addrspace(1)* %current, i32 1
	%next = select i1 %condition, i64 addrspace(1)* %maybe_next, i64 addrspace(1)* %current			%next = select i1 %condition, i64 addrspace(1)* %maybe_next, i64 addrspace(1)* %current
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %loop			br label %loop
	}			}

	declare void @do_safepoint()			declare void @do_safepoint()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers.ll

Show All 10 Lines	entry:
%obj = call i64 addrspace(1)* @generate_obj()		%obj = call i64 addrspace(1)* @generate_obj()
br label %loop		br label %loop

loop:		loop:
; CHECK: phi i64 addrspace(1)*		; CHECK: phi i64 addrspace(1)*
; CHECK-DAG: [ %obj.relocated.casted, %loop ]		; CHECK-DAG: [ %obj.relocated.casted, %loop ]
; CHECK-DAG: [ %obj, %entry ]		; CHECK-DAG: [ %obj, %entry ]
call void @use_obj(i64 addrspace(1)* %obj)		call void @use_obj(i64 addrspace(1)* %obj)
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
br label %loop		br label %loop
}		}

declare void @do_safepoint()		declare void @do_safepoint()

declare void @parse_point(i64 addrspace(1)*)		declare void @parse_point(i64 addrspace(1)*)

define i64 addrspace(1)* @test1(i32 %caller, i8 addrspace(1)* %a, i8 addrspace(1)* %b, i32 %unknown) gc "statepoint-example" {		define i64 addrspace(1)* @test1(i32 %caller, i8 addrspace(1)* %a, i8 addrspace(1)* %b, i32 %unknown) gc "statepoint-example" {
Show All 24 Lines
; CHECK: right:		; CHECK: right:
; CHECK-NEXT: %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)*		; CHECK-NEXT: %b.cast = bitcast i8 addrspace(1)* %b to i64 addrspace(1)*
; CHECK-NEXT: [[CAST_R:%.]] = bitcast i8 addrspace(1) %b to i64 addrspace(1)*		; CHECK-NEXT: [[CAST_R:%.]] = bitcast i8 addrspace(1) %b to i64 addrspace(1)*

merge:		merge:
; CHECK: merge:		; CHECK: merge:
; CHECK-NEXT: %base_phi = phi i64 addrspace(1)* [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_R]], %right ], !is_base_value !0		; CHECK-NEXT: %base_phi = phi i64 addrspace(1)* [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_L]], %left ], [ [[CAST_R]], %right ], !is_base_value !0
%value = phi i64 addrspace(1)* [ %a.cast, %left], [ %a.cast, %left], [ %a.cast, %left], [ %b.cast, %right]		%value = phi i64 addrspace(1)* [ %a.cast, %left], [ %a.cast, %left], [ %a.cast, %left], [ %b.cast, %right]
%safepoint_token = call i32 (void (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(void (i64 addrspace(1)) @parse_point, i32 1, i32 0, i64 addrspace(1)* %value, i32 0, i32 5, i32 0, i32 0, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64 0, i32 0, void (i64 addrspace(1)) @parse_point, i32 1, i32 0, i64 addrspace(1)* %value, i32 0, i32 5, i32 0, i32 0, i32 0, i32 0, i32 0)

ret i64 addrspace(1)* %value		ret i64 addrspace(1)* %value
}		}

;; The purpose of this test is to ensure that when two live values share a		;; The purpose of this test is to ensure that when two live values share a
;; base defining value with inherent conflicts, we end up with a single		;; base defining value with inherent conflicts, we end up with a single
;; base phi/select per such node. This is testing an optimization, not a		;; base phi/select per such node. This is testing an optimization, not a
;; fundemental correctness criteria		;; fundemental correctness criteria
Show All 17 Lines
; CHECK: base_select		; CHECK: base_select
; CHECK: statepoint		; CHECK: statepoint
;; Both 'next' and 'extra2' are live across the backedge safepoint...		;; Both 'next' and 'extra2' are live across the backedge safepoint...
%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]		%current = phi i64 addrspace(1)* [ %obj, %entry ], [ %next, %loop ]
%extra = phi i64 addrspace(1)* [ %obj, %entry ], [ %extra2, %loop ]		%extra = phi i64 addrspace(1)* [ %obj, %entry ], [ %extra2, %loop ]
%nexta = getelementptr i64, i64 addrspace(1)* %current, i32 1		%nexta = getelementptr i64, i64 addrspace(1)* %current, i32 1
%next = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2		%next = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2
%extra2 = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2		%extra2 = select i1 %cnd, i64 addrspace(1)* %nexta, i64 addrspace(1)* %base_arg2
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
br label %loop		br label %loop
}		}

declare void @foo()		declare void @foo()
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(void (i64 addrspace(1)), i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidp1i64f(i64, i32, void (i64 addrspace(1)), i32, i32, ...)
		No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/basics.ll

	; This is a collection of really basic tests for gc.statepoint rewriting.			; This is a collection of really basic tests for gc.statepoint rewriting.
	; RUN: opt %s -rewrite-statepoints-for-gc -S \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -S \| FileCheck %s

	declare void @foo()			declare void @foo()

	; Trivial relocation over a single call			; Trivial relocation over a single call
	define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {			define i8 addrspace(1)* @test1(i8 addrspace(1)* %obj) gc "statepoint-example" {
	; CHECK-LABEL: @test1			; CHECK-LABEL: @test1
	; CHECK-LABEL: entry:			; CHECK-LABEL: entry:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i8 addrspace(1)* %obj			ret i8 addrspace(1)* %obj
	}			}

	; Two safepoints in a row (i.e. consistent liveness)			; Two safepoints in a row (i.e. consistent liveness)
	define i8 addrspace(1)* @test2(i8 addrspace(1)* %obj) gc "statepoint-example" {			define i8 addrspace(1)* @test2(i8 addrspace(1)* %obj) gc "statepoint-example" {
	; CHECK-LABEL: @test2			; CHECK-LABEL: @test2
	; CHECK-LABEL: entry:			; CHECK-LABEL: entry:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i8 addrspace(1)* %obj			ret i8 addrspace(1)* %obj
	}			}

	; A simple derived pointer			; A simple derived pointer
	define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" {			define i8 @test3(i8 addrspace(1)* %obj) gc "statepoint-example" {
	; CHECK-LABEL: entry:			; CHECK-LABEL: entry:
	; CHECK-NEXT: getelementptr			; CHECK-NEXT: getelementptr
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %derived.relocated = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %derived.relocated = call coldcc i8 addrspace(1)*
	; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
	; CHECK-NEXT: load i8, i8 addrspace(1)* %derived.relocated			; CHECK-NEXT: load i8, i8 addrspace(1)* %derived.relocated
	; CHECK-NEXT: load i8, i8 addrspace(1)* %obj.relocated			; CHECK-NEXT: load i8, i8 addrspace(1)* %obj.relocated
	entry:			entry:
	%derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10			%derived = getelementptr i8, i8 addrspace(1)* %obj, i64 10
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)

	%a = load i8, i8 addrspace(1)* %derived			%a = load i8, i8 addrspace(1)* %derived
	%b = load i8, i8 addrspace(1)* %obj			%b = load i8, i8 addrspace(1)* %obj
	%c = sub i8 %a, %b			%c = sub i8 %a, %b
	ret i8 %c			ret i8 %c
	}			}

	; Tests to make sure we visit both the taken and untaken predeccessor			; Tests to make sure we visit both the taken and untaken predeccessor
	; of merge. This was a bug in the dataflow liveness at one point.			; of merge. This was a bug in the dataflow liveness at one point.
	define i8 addrspace(1)* @test4(i1 %cmp, i8 addrspace(1)* %obj) gc "statepoint-example" {			define i8 addrspace(1)* @test4(i1 %cmp, i8 addrspace(1)* %obj) gc "statepoint-example" {
	entry:			entry:
	br i1 %cmp, label %taken, label %untaken			br i1 %cmp, label %taken, label %untaken

	taken:			taken:
	; CHECK-LABEL: taken:			; CHECK-LABEL: taken:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %merge			br label %merge

	untaken:			untaken:
	; CHECK-LABEL: untaken:			; CHECK-LABEL: untaken:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*			; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	br label %merge			br label %merge

	merge:			merge:
	; CHECK-LABEL: merge:			; CHECK-LABEL: merge:
	; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated1, %untaken ]			; CHECK-NEXT: %.0 = phi i8 addrspace(1)* [ %obj.relocated, %taken ], [ %obj.relocated1, %untaken ]
	; CHECK-NEXT: ret i8 addrspace(1)* %.0			; CHECK-NEXT: ret i8 addrspace(1)* %.0
	ret i8 addrspace(1)* %obj			ret i8 addrspace(1)* %obj
	}			}

	; When run over a function which doesn't opt in, should do nothing!			; When run over a function which doesn't opt in, should do nothing!
	define i8 addrspace(1)* @test5(i8 addrspace(1)* %obj) gc "ocaml" {			define i8 addrspace(1)* @test5(i8 addrspace(1)* %obj) gc "ocaml" {
	; CHECK-LABEL: @test5			; CHECK-LABEL: @test5
	; CHECK-LABEL: entry:			; CHECK-LABEL: entry:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)*			; CHECK-NOT: %obj.relocated = call coldcc i8 addrspace(1)*
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i8 addrspace(1)* %obj			ret i8 addrspace(1)* %obj
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
				No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/constants.ll

	; RUN: opt -S -rewrite-statepoints-for-gc %s \| FileCheck %s			; RUN: opt -S -rewrite-statepoints-for-gc %s \| FileCheck %s

	declare void @foo()			declare void @foo()
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

	; constants don't get relocated.			; constants don't get relocated.
	define i8 @test() gc "statepoint-example" {			define i8 @test() gc "statepoint-example" {
	; CHECK-LABEL: @test			; CHECK-LABEL: @test
	; CHECK: gc.statepoint			; CHECK: gc.statepoint
	; CHECK-NEXT: load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)			; CHECK-NEXT: load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	%res = load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)			%res = load i8, i8 addrspace(1)* inttoptr (i64 15 to i8 addrspace(1)*)
	ret i8 %res			ret i8 %res
	}			}


	; Mostly just here to show reasonable code test can come from.			; Mostly just here to show reasonable code test can come from.
	define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" {			define i8 @test2(i8 addrspace(1)* %p) gc "statepoint-example" {
	; CHECK-LABEL: @test2			; CHECK-LABEL: @test2
	; CHECK: gc.statepoint			; CHECK: gc.statepoint
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: icmp			; CHECK-NEXT: icmp
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	%cmp = icmp eq i8 addrspace(1)* %p, null			%cmp = icmp eq i8 addrspace(1)* %p, null
	br i1 %cmp, label %taken, label %not_taken			br i1 %cmp, label %taken, label %not_taken

	taken:			taken:
	ret i8 0			ret i8 0

	not_taken:			not_taken:
	%cmp2 = icmp ne i8 addrspace(1)* %p, null			%cmp2 = icmp ne i8 addrspace(1)* %p, null
	Show All 13 Lines
	@G = addrspace(1) global i8 5			@G = addrspace(1) global i8 5

	; Globals don't move and thus don't get relocated			; Globals don't move and thus don't get relocated
	define i8 @test3(i1 %always_true) gc "statepoint-example" {			define i8 @test3(i1 %always_true) gc "statepoint-example" {
	; CHECK-LABEL: @test3			; CHECK-LABEL: @test3
	; CHECK: gc.statepoint			; CHECK: gc.statepoint
	; CHECK-NEXT: load i8, i8 addrspace(1)* @G			; CHECK-NEXT: load i8, i8 addrspace(1)* @G
	entry:			entry:
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	%res = load i8, i8 addrspace(1)* @G, align 1			%res = load i8, i8 addrspace(1)* @G, align 1
	ret i8 %res			ret i8 %res
	}			}

llvm/trunk/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll

	; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 \| FileCheck %s
	; This test is to verify gc.relocate can handle pointer to vector of			; This test is to verify gc.relocate can handle pointer to vector of
	; pointers (<2 x i32 addrspace(1)> addrspace(1) in this case).			; pointers (<2 x i32 addrspace(1)> addrspace(1) in this case).
	; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)> addrspace(1)			; The old scheme to create a gc.relocate of <2 x i32 addrspace(1)> addrspace(1)
	; type will fail because llvm does not support mangling vector of pointers.			; type will fail because llvm does not support mangling vector of pointers.
	; The new scheme will create all gc.relocate to i8 addrspace(1)* type and			; The new scheme will create all gc.relocate to i8 addrspace(1)* type and
	; then bitcast to the correct type.			; then bitcast to the correct type.

	declare void @foo()			declare void @foo()
	declare void @use(...)			declare void @use(...)
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

	define void @test1(<2 x i32 addrspace(1)> addrspace(1) %obj) gc "statepoint-example" {			define void @test1(<2 x i32 addrspace(1)> addrspace(1) %obj) gc "statepoint-example" {
	entry:			entry:
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	; CHECK: %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 5, i32 5)			; CHECK: %obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 7, i32 7)
	; CHECK-NEXT: %obj.relocated.casted = bitcast i8 addrspace(1)* %obj.relocated to <2 x i32 addrspace(1)> addrspace(1)			; CHECK-NEXT: %obj.relocated.casted = bitcast i8 addrspace(1)* %obj.relocated to <2 x i32 addrspace(1)> addrspace(1)
	call void (...) @use(<2 x i32 addrspace(1)> addrspace(1) %obj)			call void (...) @use(<2 x i32 addrspace(1)> addrspace(1) %obj)
	ret void			ret void
	}			}
	No newline at end of file

llvm/trunk/test/Transforms/RewriteStatepointsForGC/live-vector.ll

	; Test that we can correctly handle vectors of pointers in statepoint			; Test that we can correctly handle vectors of pointers in statepoint
	; rewriting. Currently, we scalarize, but that's an implementation detail.			; rewriting. Currently, we scalarize, but that's an implementation detail.
	; RUN: opt %s -rewrite-statepoints-for-gc -S \| FileCheck %s			; RUN: opt %s -rewrite-statepoints-for-gc -S \| FileCheck %s

	; A non-vector relocation for comparison			; A non-vector relocation for comparison
	define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {			define i64 addrspace(1)* @test(i64 addrspace(1)* %obj) gc "statepoint-example" {
	; CHECK-LABEL: test			; CHECK-LABEL: test
	; CHECK: gc.statepoint			; CHECK: gc.statepoint
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted			; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted
	entry:			entry:
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
	ret i64 addrspace(1)* %obj			ret i64 addrspace(1)* %obj
	}			}

	; A base vector from a argument			; A base vector from a argument
	define <2 x i64 addrspace(1)> @test2(<2 x i64 addrspace(1)> %obj) gc "statepoint-example" {			define <2 x i64 addrspace(1)> @test2(<2 x i64 addrspace(1)> %obj) gc "statepoint-example" {
	; CHECK-LABEL: test2			; CHECK-LABEL: test2
	; CHECK: extractelement			; CHECK: extractelement
	; CHECK-NEXT: extractelement			; CHECK-NEXT: extractelement
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7			; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
	entry:			entry:
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
	ret <2 x i64 addrspace(1)*> %obj			ret <2 x i64 addrspace(1)*> %obj
	}			}

	; A base vector from a load			; A base vector from a load
	define <2 x i64 addrspace(1)> @test3(<2 x i64 addrspace(1)>* %ptr) gc "statepoint-example" {			define <2 x i64 addrspace(1)> @test3(<2 x i64 addrspace(1)>* %ptr) gc "statepoint-example" {
	; CHECK-LABEL: test3			; CHECK-LABEL: test3
	; CHECK: load			; CHECK: load
	; CHECK-NEXT: extractelement			; CHECK-NEXT: extractelement
	; CHECK-NEXT: extractelement			; CHECK-NEXT: extractelement
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7			; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
	entry:			entry:
	%obj = load <2 x i64 addrspace(1)>, <2 x i64 addrspace(1)>* %ptr			%obj = load <2 x i64 addrspace(1)>, <2 x i64 addrspace(1)>* %ptr
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
	ret <2 x i64 addrspace(1)*> %obj			ret <2 x i64 addrspace(1)*> %obj
	}			}

	declare i32 @fake_personality_function()			declare i32 @fake_personality_function()

	; When a statepoint is an invoke rather than a call			; When a statepoint is an invoke rather than a call
	define <2 x i64 addrspace(1)> @test4(<2 x i64 addrspace(1)>* %ptr) gc "statepoint-example" {			define <2 x i64 addrspace(1)> @test4(<2 x i64 addrspace(1)>* %ptr) gc "statepoint-example" {
	; CHECK-LABEL: test4			; CHECK-LABEL: test4
	; CHECK: load			; CHECK: load
	; CHECK-NEXT: extractelement			; CHECK-NEXT: extractelement
	; CHECK-NEXT: extractelement			; CHECK-NEXT: extractelement
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	entry:			entry:
	%obj = load <2 x i64 addrspace(1)>, <2 x i64 addrspace(1)>* %ptr			%obj = load <2 x i64 addrspace(1)>, <2 x i64 addrspace(1)>* %ptr
	invoke i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)			invoke i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
	to label %normal_return unwind label %exceptional_return			to label %normal_return unwind label %exceptional_return

	; CHECK-LABEL: normal_return:			; CHECK-LABEL: normal_return:
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	Show All 32 Lines
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: insertelement			; CHECK-NEXT: insertelement
	; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7			; CHECK-NEXT: ret <2 x i64 addrspace(1)*> %7
	entry:			entry:
	%vec = insertelement <2 x i64 addrspace(1)> undef, i64 addrspace(1) %p, i32 0			%vec = insertelement <2 x i64 addrspace(1)> undef, i64 addrspace(1) %p, i32 0
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
	ret <2 x i64 addrspace(1)*> %vec			ret <2 x i64 addrspace(1)*> %vec
	}			}

	declare void @do_safepoint()			declare void @do_safepoint()

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll

Show All 10 Lines	entry:
br i1 %cmp, label %taken, label %untaken		br i1 %cmp, label %taken, label %untaken

taken:		taken:
; CHECK-LABEL: taken:		; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*		; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %merge		br label %merge

untaken:		untaken:
; CHECK-LABEL: untaken:		; CHECK-LABEL: untaken:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*		; CHECK-NEXT: %obj.relocated1 = call coldcc i8 addrspace(1)*
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %merge		br label %merge

merge:		merge:
; CHECK-LABEL: merge:		; CHECK-LABEL: merge:
; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated1.casted, %untaken ]		; CHECK-NEXT: %.0 = phi i64 addrspace(1)* [ %obj.relocated.casted, %taken ], [ %obj.relocated1.casted, %untaken ]
; CHECK-NEXT: ret i64 addrspace(1)* %.0		; CHECK-NEXT: ret i64 addrspace(1)* %.0
ret i64 addrspace(1)* %obj		ret i64 addrspace(1)* %obj
}		}

; A local kill should not effect liveness in predecessor block		; A local kill should not effect liveness in predecessor block
define i64 addrspace(1)* @test2(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {		define i64 addrspace(1)* @test2(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
; CHECK-LABEL: @test2		; CHECK-LABEL: @test2
entry:		entry:
; CHECK-LABEL: entry:		; CHECK-LABEL: entry:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: br		; CHECK-NEXT: br
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br i1 %cmp, label %taken, label %untaken		br i1 %cmp, label %taken, label %untaken

taken:		taken:
; CHECK-LABEL: taken:		; CHECK-LABEL: taken:
; CHECK-NEXT: %obj = load		; CHECK-NEXT: %obj = load
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: gc.relocate		; CHECK-NEXT: gc.relocate
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted		; CHECK-NEXT: ret i64 addrspace(1)* %obj.relocated.casted

%obj = load i64 addrspace(1), i64 addrspace(1)* %loc		%obj = load i64 addrspace(1), i64 addrspace(1)* %loc
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
ret i64 addrspace(1)* %obj		ret i64 addrspace(1)* %obj

untaken:		untaken:
ret i64 addrspace(1)* null		ret i64 addrspace(1)* null
}		}

; A local kill should effect values live from a successor phi. Also, we		; A local kill should effect values live from a successor phi. Also, we
; should only propagate liveness from a phi to the appropriate predecessors.		; should only propagate liveness from a phi to the appropriate predecessors.
define i64 addrspace(1)* @test3(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {		define i64 addrspace(1)* @test3(i1 %cmp, i64 addrspace(1)** %loc) gc "statepoint-example" {
; CHECK-LABEL: @test3		; CHECK-LABEL: @test3
entry:		entry:
br i1 %cmp, label %taken, label %untaken		br i1 %cmp, label %taken, label %untaken

taken:		taken:
; CHECK-LABEL: taken:		; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj = load		; CHECK-NEXT: %obj = load
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*		; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
%obj = load i64 addrspace(1), i64 addrspace(1)* %loc		%obj = load i64 addrspace(1), i64 addrspace(1)* %loc
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %merge		br label %merge

untaken:		untaken:
; CHECK-LABEL: taken:		; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %merge		br label %merge

merge:		merge:
%phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]		%phi = phi i64 addrspace(1)* [ %obj, %taken ], [ null, %untaken ]
ret i64 addrspace(1)* %phi		ret i64 addrspace(1)* %phi
}		}

; A base pointer must be live if it is needed at a later statepoint,		; A base pointer must be live if it is needed at a later statepoint,
Show All 12 Lines
; CHECK-NEXT: %derived.relocated1 =		; CHECK-NEXT: %derived.relocated1 =
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; Note: It's legal to relocate obj again, but not strictly needed		; Note: It's legal to relocate obj again, but not strictly needed
; CHECK-NEXT: %obj.relocated2 =		; CHECK-NEXT: %obj.relocated2 =
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: ret i64 addrspace(1)* %derived.relocated1.casted		; CHECK-NEXT: ret i64 addrspace(1)* %derived.relocated1.casted
;		;
%derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8		%derived = getelementptr i64, i64 addrspace(1)* %obj, i64 8
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)

call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
ret i64 addrspace(1)* %derived		ret i64 addrspace(1)* %derived
}		}

declare void @consume(...) readonly		declare void @consume(...) readonly

; Make sure that a phi def visited during iteration is considered a kill.		; Make sure that a phi def visited during iteration is considered a kill.
; Also, liveness after base pointer analysis can change based on new uses,		; Also, liveness after base pointer analysis can change based on new uses,
; not just new defs.		; not just new defs.
define i64 addrspace(1)* @test5(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {		define i64 addrspace(1)* @test5(i1 %cmp, i64 addrspace(1)* %obj) gc "statepoint-example" {
; CHECK-LABEL: @test5		; CHECK-LABEL: @test5
entry:		entry:
br i1 %cmp, label %taken, label %untaken		br i1 %cmp, label %taken, label %untaken

taken:		taken:
; CHECK-LABEL: taken:		; CHECK-LABEL: taken:
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*		; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %merge		br label %merge

untaken:		untaken:
; CHECK-LABEL: untaken:		; CHECK-LABEL: untaken:
; CHECK-NEXT: br label %merge		; CHECK-NEXT: br label %merge
br label %merge		br label %merge

merge:		merge:
Show All 10 Lines
; CHECK-NEXT: @consume		; CHECK-NEXT: @consume
; CHECK-NEXT: ret i64 addrspace(1)* %.0		; CHECK-NEXT: ret i64 addrspace(1)* %.0
call void (...) @consume(i64 addrspace(1)* %obj2a)		call void (...) @consume(i64 addrspace(1)* %obj2a)
ret i64 addrspace(1)* %obj		ret i64 addrspace(1)* %obj
}		}

declare void @foo()		declare void @foo()

declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/preprocess.ll

	Show All 11 Lines
	next:			next:
	; CHECK-LABEL: next:			; CHECK-LABEL: next:
	; CHECK-NEXT: gc.statepoint			; CHECK-NEXT: gc.statepoint
	; CHECK-NEXT: gc.relocate			; CHECK-NEXT: gc.relocate
	; CHECK-NEXT: bitcast			; CHECK-NEXT: bitcast
	; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)			; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
	; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)			; CHECK-NEXT: @consume(i64 addrspace(1)* %obj.relocated.casted)
	%obj2 = phi i64 addrspace(1)* [ %obj, %entry ]			%obj2 = phi i64 addrspace(1)* [ %obj, %entry ]
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	call void (...) @consume(i64 addrspace(1)* %obj2)			call void (...) @consume(i64 addrspace(1)* %obj2)
	call void (...) @consume(i64 addrspace(1)* %obj)			call void (...) @consume(i64 addrspace(1)* %obj)
	ret void			ret void
	}			}

	declare void @some_call(i64 addrspace(1)*)			declare void @some_call(i64 addrspace(1)*)

	; Need to delete unreachable gc.statepoint call			; Need to delete unreachable gc.statepoint call
	define void @test7() gc "statepoint-example" {			define void @test7() gc "statepoint-example" {
	; CHECK-LABEL: test7			; CHECK-LABEL: test7
	; CHECK-NOT: gc.statepoint			; CHECK-NOT: gc.statepoint
	ret void			ret void

	unreached:			unreached:
	%obj = phi i64 addrspace(1)* [null, %unreached]			%obj = phi i64 addrspace(1)* [null, %unreached]
	call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	call void (...) @consume(i64 addrspace(1)* %obj)			call void (...) @consume(i64 addrspace(1)* %obj)
	br label %unreached			br label %unreached
	}			}

	; Need to delete unreachable gc.statepoint invoke - tested seperately given			; Need to delete unreachable gc.statepoint invoke - tested seperately given
	; a correct implementation could only remove the instructions, not the block			; a correct implementation could only remove the instructions, not the block
	define void @test8() gc "statepoint-example" {			define void @test8() gc "statepoint-example" {
	; CHECK-LABEL: test8			; CHECK-LABEL: test8
	; CHECK-NOT: gc.statepoint			; CHECK-NOT: gc.statepoint
	ret void			ret void

	unreached:			unreached:
	invoke i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)			invoke i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
	to label %normal_return unwind label %exceptional_return			to label %normal_return unwind label %exceptional_return

	normal_return: ; preds = %entry			normal_return: ; preds = %entry
	ret void			ret void

	exceptional_return: ; preds = %entry			exceptional_return: ; preds = %entry
	%landing_pad4 = landingpad { i8, i32 } personality i32 () undef			%landing_pad4 = landingpad { i8, i32 } personality i32 () undef
	cleanup			cleanup
	ret void			ret void
	}			}

	declare void @foo()			declare void @foo()
	; Bound the last check-not			; Bound the last check-not
	; CHECK-LABEL: @foo			; CHECK-LABEL: @foo

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll

	Show All 17 Lines
	unwind_dest:			unwind_dest:
	%lpad = landingpad { i8, i32 } personality i32 ()* @fake_personality_function			%lpad = landingpad { i8, i32 } personality i32 ()* @fake_personality_function
	cleanup			cleanup
	resume { i8*, i32 } undef			resume { i8*, i32 } undef

	normal_dest:			normal_dest:
	;; CHECK-LABEL: normal_dest:			;; CHECK-LABEL: normal_dest:
	;; CHECK-NEXT: gc.statepoint			;; CHECK-NEXT: gc.statepoint
	;; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*			;; CHECK-NEXT: %obj.relocated = call coldcc i8 addrspace(1)*
	;; CHECK-NEXT: bitcast			;; CHECK-NEXT: bitcast
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @gc_call, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @gc_call, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
	ret i64* addrspace(1)* %obj			ret i64* addrspace(1)* %obj
	}			}

	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocation.ll

; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 \| FileCheck %s		; RUN: opt %s -rewrite-statepoints-for-gc -S 2>&1 \| FileCheck %s


declare void @foo()		declare void @foo()
declare void @use(...)		declare void @use(...)

define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {		define i64 addrspace(1)* @test1(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
entry:		entry:
; CHECK-LABEL: @test1		; CHECK-LABEL: @test1
; CHECK-DAG: %obj.relocated		; CHECK-DAG: %obj.relocated
; CHECK-DAG: %obj2.relocated		; CHECK-DAG: %obj2.relocated
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %joint		br label %joint

joint:		joint:
; CHECK-LABEL: joint:		; CHECK-LABEL: joint:
; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]		; CHECK: %phi1 = phi i64 addrspace(1)* [ %obj.relocated.casted, %entry ], [ %obj3, %joint2 ]
%phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]		%phi1 = phi i64 addrspace(1)* [ %obj, %entry ], [ %obj3, %joint2 ]
br i1 %condition, label %use, label %joint2		br i1 %condition, label %use, label %joint2

Show All 35 Lines	; CHECK-NOT: %location = getelementptr i64, i64 addrspace(1)* %obj, i32 %index
%index.inc = add i32 %index, 1		%index.inc = add i32 %index, 1
%condition = call i1 @rt()		%condition = call i1 @rt()
br i1 %condition, label %loop_x, label %loop_y		br i1 %condition, label %loop_x, label %loop_y

loop_x:		loop_x:
br label %loop.backedge		br label %loop.backedge

loop.backedge:		loop.backedge:
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @do_safepoint, i32 0, i32 0, i32 0, i32 0)
br label %loop		br label %loop

loop_y:		loop_y:
br label %loop.backedge		br label %loop.backedge
}		}

declare void @some_call(i8 addrspace(1)*)		declare void @some_call(i8 addrspace(1)*)

define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {		define void @relocate_merge(i1 %cnd, i8 addrspace(1)* %arg) gc "statepoint-example" {
; CHECK-LABEL: @relocate_merge		; CHECK-LABEL: @relocate_merge
bci_0:		bci_0:
br i1 %cnd, label %if_branch, label %else_branch		br i1 %cnd, label %if_branch, label %else_branch

if_branch:		if_branch:
; CHECK-LABEL: if_branch:		; CHECK-LABEL: if_branch:
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: gc.relocate		; CHECK: gc.relocate
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %join		br label %join

else_branch:		else_branch:
; CHECK-LABEL: else_branch:		; CHECK-LABEL: else_branch:
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: gc.relocate		; CHECK: gc.relocate
%safepoint_token1 = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 0)		%safepoint_token1 = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 0)
br label %join		br label %join

join:		join:
; We need to end up with a single relocation phi updated from both paths		; We need to end up with a single relocation phi updated from both paths
; CHECK-LABEL: join:		; CHECK-LABEL: join:
; CHECK: phi i8 addrspace(1)*		; CHECK: phi i8 addrspace(1)*
; CHECK-DAG: [ %arg.relocated, %if_branch ]		; CHECK-DAG: [ %arg.relocated, %if_branch ]
; CHECK-DAG: [ %arg.relocated4, %else_branch ]		; CHECK-DAG: [ %arg.relocated4, %else_branch ]
; CHECK-NOT: phi		; CHECK-NOT: phi
call void (i8 addrspace(1)) @some_call(i8 addrspace(1) %arg)		call void (i8 addrspace(1)) @some_call(i8 addrspace(1) %arg)
ret void		ret void
}		}

; Make sure a use in a statepoint gets properly relocated at a previous one.		; Make sure a use in a statepoint gets properly relocated at a previous one.
; This is basically just making sure that statepoints aren't accidentally		; This is basically just making sure that statepoints aren't accidentally
; treated specially.		; treated specially.
define void @test3(i64 addrspace(1)* %obj) gc "statepoint-example" {		define void @test3(i64 addrspace(1)* %obj) gc "statepoint-example" {
entry:		entry:
; CHECK-LABEL: @test3		; CHECK-LABEL: @test3
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK-NEXT: gc.relocate		; CHECK-NEXT: gc.relocate
; CHECK-NEXT: bitcast		; CHECK-NEXT: bitcast
; CHECK-NEXT: gc.statepoint		; CHECK-NEXT: gc.statepoint
%safepoint_token = call i32 (void (i64), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi64f(void (i64) undef, i32 1, i32 0, i64 undef, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (i64), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64 0, i32 0, void (i64) undef, i32 1, i32 0, i64 undef, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
%safepoint_token1 = call i32 (i32 (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i32 (i64 addrspace(1)) undef, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token1 = call i32 (i64, i32, i32 (i64 addrspace(1)), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64 0, i32 0, i32 (i64 addrspace(1)) undef, i32 1, i32 0, i64 addrspace(1)* %obj, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
ret void		ret void
}		}

; Check specifically for the case where the result of a statepoint needs to		; Check specifically for the case where the result of a statepoint needs to
; be relocated itself		; be relocated itself
define void @test4() gc "statepoint-example" {		define void @test4() gc "statepoint-example" {
; CHECK-LABEL: @test4		; CHECK-LABEL: @test4
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: gc.result		; CHECK: gc.result
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: gc.relocate		; CHECK: gc.relocate
; CHECK: @use(i8 addrspace(1)* %res.relocated)		; CHECK: @use(i8 addrspace(1)* %res.relocated)
%safepoint_token2 = tail call i32 (i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)		%safepoint_token2 = tail call i32 (i64, i32, i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)
%res = call i8 addrspace(1)* @llvm.experimental.gc.result.ptr.p1i8(i32 %safepoint_token2)		%res = call i8 addrspace(1)* @llvm.experimental.gc.result.ptr.p1i8(i32 %safepoint_token2)
call i32 (i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)
call void (...) @use(i8 addrspace(1)* %res)		call void (...) @use(i8 addrspace(1)* %res)
unreachable		unreachable
}		}


; Test updating a phi where not all inputs are live to begin with		; Test updating a phi where not all inputs are live to begin with
define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {		define void @test5(i8 addrspace(1)* %arg) gc "statepoint-example" {
; CHECK-LABEL: test5		; CHECK-LABEL: test5
entry:		entry:
call i32 (i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)		call i32 (i64, i32, i8 addrspace(1)* (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_p1i8f(i64 0, i32 0, i8 addrspace(1) ()* undef, i32 0, i32 0, i32 0, i32 0)
switch i32 undef, label %kill [		switch i32 undef, label %kill [
i32 10, label %merge		i32 10, label %merge
i32 13, label %merge		i32 13, label %merge
]		]

kill:		kill:
br label %merge		br label %merge

Show All 17 Lines	entry:
br i1 undef, label %gc.safepoint_poll.exit2, label %do_safepoint		br i1 undef, label %gc.safepoint_poll.exit2, label %do_safepoint

do_safepoint:		do_safepoint:
; CHECK-LABEL: do_safepoint:		; CHECK-LABEL: do_safepoint:
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: arg1.relocated =		; CHECK: arg1.relocated =
; CHECK: arg2.relocated =		; CHECK: arg2.relocated =
; CHECK: arg3.relocated =		; CHECK: arg3.relocated =
call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 3, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)		call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 3, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2, i8 addrspace(1)* %arg3)
br label %gc.safepoint_poll.exit2		br label %gc.safepoint_poll.exit2

gc.safepoint_poll.exit2:		gc.safepoint_poll.exit2:
; CHECK-LABEL: gc.safepoint_poll.exit2:		; CHECK-LABEL: gc.safepoint_poll.exit2:
; CHECK: phi i8 addrspace(1)*		; CHECK: phi i8 addrspace(1)*
; CHECK-DAG: [ %arg3, %entry ]		; CHECK-DAG: [ %arg3, %entry ]
; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]		; CHECK-DAG: [ %arg3.relocated, %do_safepoint ]
; CHECK: phi i8 addrspace(1)*		; CHECK: phi i8 addrspace(1)*
Show All 22 Lines

inner-loop:		inner-loop:
br i1 %cmp, label %inner-loop, label %outer-inc		br i1 %cmp, label %inner-loop, label %outer-inc

outer-inc:		outer-inc:
; CHECK-LABEL: outer-inc:		; CHECK-LABEL: outer-inc:
; CHECK: %arg1.relocated		; CHECK: %arg1.relocated
; CHECK: %arg2.relocated		; CHECK: %arg2.relocated
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2)
br label %outer-loop		br label %outer-loop
}		}

; Check that both inner and outer loops get phis when relocation is in		; Check that both inner and outer loops get phis when relocation is in
; inner loop		; inner loop
define void @test_inner_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2,		define void @test_inner_loop(i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2,
i1 %cmp) gc "statepoint-example" {		i1 %cmp) gc "statepoint-example" {
; CHECK-LABEL: @test_inner_loop		; CHECK-LABEL: @test_inner_loop
Show All 12 Lines
; CHECK-DAG: %outer-loop ]		; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg2.relocated, %inner-loop ]		; CHECK-DAG: [ %arg2.relocated, %inner-loop ]
; CHECKL phi i8 addrspace(1)*		; CHECKL phi i8 addrspace(1)*
; CHECK-DAG: %outer-loop ]		; CHECK-DAG: %outer-loop ]
; CHECK-DAG: [ %arg1.relocated, %inner-loop ]		; CHECK-DAG: [ %arg1.relocated, %inner-loop ]
; CHECK: gc.statepoint		; CHECK: gc.statepoint
; CHECK: %arg1.relocated		; CHECK: %arg1.relocated
; CHECK: %arg2.relocated		; CHECK: %arg2.relocated
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 2, i8 addrspace(1)* %arg1, i8 addrspace(1)* %arg2)
br i1 %cmp, label %inner-loop, label %outer-inc		br i1 %cmp, label %inner-loop, label %outer-inc

outer-inc:		outer-inc:
; CHECK-LABEL: outer-inc:		; CHECK-LABEL: outer-inc:
br label %outer-loop		br label %outer-loop
}		}


; This test shows why updating just those uses of the original value being		; This test shows why updating just those uses of the original value being
; relocated dominated by the inserted relocation is not always sufficient.		; relocated dominated by the inserted relocation is not always sufficient.
define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {		define i64 addrspace(1)* @test7(i64 addrspace(1)* %obj, i64 addrspace(1)* %obj2, i1 %condition) gc "statepoint-example" {
; CHECK-LABEL: @test7		; CHECK-LABEL: @test7
entry:		entry:
br i1 %condition, label %branch2, label %join		br i1 %condition, label %branch2, label %join

branch2:		branch2:
br i1 %condition, label %callbb, label %join2		br i1 %condition, label %callbb, label %join2

callbb:		callbb:
%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)		%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () @foo, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0)
br label %join		br label %join

join:		join:
; CHECK-LABEL: join:		; CHECK-LABEL: join:
; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]		; CHECK: phi i64 addrspace(1)* [ %obj.relocated.casted, %callbb ], [ %obj, %entry ]
; CHECK: phi i64 addrspace(1)*		; CHECK: phi i64 addrspace(1)*
; CHECK-DAG: [ %obj, %entry ]		; CHECK-DAG: [ %obj, %entry ]
; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]		; CHECK-DAG: [ %obj2.relocated.casted, %callbb ]
Show All 10 Lines
; CHECK-DAG: [ %obj2, %branch2 ]		; CHECK-DAG: [ %obj2, %branch2 ]
%phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]		%phi2 = phi i64 addrspace(1)* [ %obj, %join ], [ %obj2, %branch2 ]
ret i64 addrspace(1)* %phi2		ret i64 addrspace(1)* %phi2
}		}


declare void @do_safepoint()		declare void @do_safepoint()

declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
declare i32 @llvm.experimental.gc.statepoint.p0f_p1i8f(i8 addrspace(1)* ()*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_p1i8f(i64, i32, i8 addrspace(1)* ()*, i32, i32, ...)
declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi64f(void (i64)*, i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidi64f(i64, i32, void (i64)*, i32, i32, ...)
declare i32 @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i32 (i64 addrspace(1)), i32, i32, ...)		declare i32 @llvm.experimental.gc.statepoint.p0f_i32p1i64f(i64, i32, i32 (i64 addrspace(1)), i32, i32, ...)
declare i8 addrspace(1)* @llvm.experimental.gc.result.ptr.p1i8(i32) #3		declare i8 addrspace(1)* @llvm.experimental.gc.result.ptr.p1i8(i32) #3

llvm/trunk/test/Verifier/invalid-patchable-statepoint.ll

				; RUN: not opt -verify 2>&1 < %s \| FileCheck %s

				; CHECK: gc.statepoint must have null as call target if number of patchable bytes is non zero

				define i1 @invalid_patchable_statepoint() gc "statepoint-example" {
				entry:
				%safepoint_token = tail call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_i1f(i64 0, i32 3, i1 () @func, i32 0, i32 0, i32 0, i32 0)
				%call1 = call i1 @llvm.experimental.gc.result.i1(i32 %safepoint_token)
				ret i1 %call1
				}

				declare i32 @llvm.experimental.gc.statepoint.p0f_i1f(i64, i32, i1 ()*, i32, i32, ...)
				declare i1 @llvm.experimental.gc.result.i1(i32)
				declare i1 @func()

llvm/trunk/test/Verifier/invalid-statepoint.ll

	; RUN: not opt -verify 2>&1 < %s \| FileCheck %s			; RUN: not opt -verify 2>&1 < %s \| FileCheck %s

	; CHECK: gc.statepoint: mismatch in number of call arguments			; CHECK: gc.statepoint: mismatch in number of call arguments

	declare zeroext i1 @return0i1()			declare zeroext i1 @return0i1()

	; Function Attrs: nounwind			; Function Attrs: nounwind
	declare i32 @llvm.experimental.gc.statepoint.p0f0i1f(i1 ()*, i32, i32, ...) #0			declare i32 @llvm.experimental.gc.statepoint.p0f0i1f(i64, i32, i1 ()*, i32, i32, ...) #0

	; Function Attrs: nounwind			; Function Attrs: nounwind
	declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #0			declare i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32, i32, i32) #0

	define i32 addrspace(1)* @0(i32 addrspace(1)* %dparam) {			define i32 addrspace(1)* @0(i32 addrspace(1)* %dparam) {
	%a00 = load i32, i32 addrspace(1)* %dparam			%a00 = load i32, i32 addrspace(1)* %dparam
	%to0 = call i32 (i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f0i1f(i1 () @return0i1, i32 9, i32 0, i2 0, i32 addrspace(1)* %dparam)			%to0 = call i32 (i64, i32, i1 (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f0i1f(i64 0, i32 0, i1 () @return0i1, i32 9, i32 0, i2 0, i32 addrspace(1)* %dparam)
	%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %to0, i32 0, i32 4)			%relocate = call i32 addrspace(1)* @llvm.experimental.gc.relocate.p1i32(i32 %to0, i32 2, i32 6)
	ret i32 addrspace(1)* %relocate			ret i32 addrspace(1)* %relocate
	}			}

	attributes #0 = { nounwind }			attributes #0 = { nounwind }
				No newline at end of file

llvm/trunk/test/Verifier/invalid-statepoint2.ll

	; RUN: not opt -S < %s -verify 2>&1 \| FileCheck %s			; RUN: not opt -S < %s -verify 2>&1 \| FileCheck %s

	; CHECK: gc.statepoint: number of deoptimization arguments must be a constant integer			; CHECK: gc.statepoint: number of deoptimization arguments must be a constant integer

	declare void @use(...)			declare void @use(...)
	declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32)			declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32)
	declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)			declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
	declare i32 @"personality_function"()			declare i32 @"personality_function"()

	;; Basic usage			;; Basic usage
	define i64 addrspace(1)* @test1(i8 addrspace(1)* %arg, i32 %val) gc "statepoint-example" {			define i64 addrspace(1)* @test1(i8 addrspace(1)* %arg, i32 %val) gc "statepoint-example" {
	entry:			entry:
	%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*			%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 %val, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 %val, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)
	%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 10, i32 11)			%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 12, i32 13)
	ret i64 addrspace(1)* %reloc			ret i64 addrspace(1)* %reloc
	}			}

llvm/trunk/test/Verifier/statepoint.ll

	; RUN: opt -S %s -verify \| FileCheck %s			; RUN: opt -S %s -verify \| FileCheck %s

	declare void @use(...)			declare void @use(...)
	declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32)			declare i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32, i32, i32)
	declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)			declare i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32, i32, i32)
	declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(void ()*, i32, i32, ...)			declare i32 @llvm.experimental.gc.statepoint.p0f_isVoidf(i64, i32, void ()*, i32, i32, ...)
	declare i32 @"personality_function"()			declare i32 @"personality_function"()

	;; Basic usage			;; Basic usage
	define i64 addrspace(1)* @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {			define i64 addrspace(1)* @test1(i8 addrspace(1)* %arg) gc "statepoint-example" {
	entry:			entry:
	%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*			%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)
	%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 10, i32 11)			%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 12, i32 13)
	;; It is perfectly legal to relocate the same value multiple times...			;; It is perfectly legal to relocate the same value multiple times...
	%reloc2 = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 10, i32 11)			%reloc2 = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 12, i32 13)
	%reloc3 = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 11, i32 10)			%reloc3 = call i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %safepoint_token, i32 13, i32 12)
	ret i64 addrspace(1)* %reloc			ret i64 addrspace(1)* %reloc
	; CHECK-LABEL: test1			; CHECK-LABEL: test1
	; CHECK: statepoint			; CHECK: statepoint
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: ret i64 addrspace(1)* %reloc			; CHECK: ret i64 addrspace(1)* %reloc
	}			}

	; This test catches two cases where the verifier was too strict:			; This test catches two cases where the verifier was too strict:
	; 1) A base doesn't need to be relocated if it's never used again			; 1) A base doesn't need to be relocated if it's never used again
	; 2) A value can be replaced by one which is known equal. This			; 2) A value can be replaced by one which is known equal. This
	; means a potentially derived pointer can be known base and that			; means a potentially derived pointer can be known base and that
	; we can't check that derived pointer are never bases.			; we can't check that derived pointer are never bases.
	define void @test2(i8 addrspace(1)* %arg, i64 addrspace(1)* %arg2) gc "statepoint-example" {			define void @test2(i8 addrspace(1)* %arg, i64 addrspace(1)* %arg2) gc "statepoint-example" {
	entry:			entry:
	%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*			%cast = bitcast i8 addrspace(1)* %arg to i64 addrspace(1)*
	%c = icmp eq i64 addrspace(1)* %cast, %arg2			%c = icmp eq i64 addrspace(1)* %cast, %arg2
	br i1 %c, label %equal, label %notequal			br i1 %c, label %equal, label %notequal

	notequal:			notequal:
	ret void			ret void

	equal:			equal:
	%safepoint_token = call i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)			%safepoint_token = call i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 0, i32 0, i32 10, i32 0, i8 addrspace(1)* %arg, i64 addrspace(1)* %cast, i8 addrspace(1)* %arg, i8 addrspace(1)* %arg)
	%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 10, i32 11)			%reloc = call i64 addrspace(1)* @llvm.experimental.gc.relocate.p1i64(i32 %safepoint_token, i32 12, i32 13)
	call void undef(i64 addrspace(1)* %reloc)			call void undef(i64 addrspace(1)* %reloc)
	ret void			ret void
	; CHECK-LABEL: test2			; CHECK-LABEL: test2
	; CHECK-LABEL: equal			; CHECK-LABEL: equal
	; CHECK: statepoint			; CHECK: statepoint
	; CHECK-NEXT: %reloc = call			; CHECK-NEXT: %reloc = call
	; CHECK-NEXT: call			; CHECK-NEXT: call
	; CHECK-NEXT: ret voi			; CHECK-NEXT: ret voi
	}			}

	; Basic test for invoke statepoints			; Basic test for invoke statepoints
	define i8 addrspace(1)* @test3(i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1) gc "statepoint-example" {			define i8 addrspace(1)* @test3(i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1) gc "statepoint-example" {
	; CHECK-LABEL: test3			; CHECK-LABEL: test3
	entry:			entry:
	; CHECK-LABEL: entry			; CHECK-LABEL: entry
	; CHECK: statepoint			; CHECK: statepoint
	%0 = invoke i32 (void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1)			%0 = invoke i32 (i64, i32, void (), i32, i32, ...) @llvm.experimental.gc.statepoint.p0f_isVoidf(i64 0, i32 0, void () undef, i32 0, i32 0, i32 0, i32 5, i32 0, i32 -1, i32 0, i32 0, i32 0, i8 addrspace(1)* %obj, i8 addrspace(1)* %obj1)
	to label %normal_dest unwind label %exceptional_return			to label %normal_dest unwind label %exceptional_return

	normal_dest:			normal_dest:
	; CHECK-LABEL: normal_dest:			; CHECK-LABEL: normal_dest:
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: ret			; CHECK: ret
	%obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 10, i32 10)			%obj.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 12, i32 12)
	%obj1.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 10, i32 10)			%obj1.relocated = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %0, i32 12, i32 12)
	ret i8 addrspace(1)* %obj.relocated			ret i8 addrspace(1)* %obj.relocated

	exceptional_return:			exceptional_return:
	; CHECK-LABEL: exceptional_return			; CHECK-LABEL: exceptional_return
	; CHECK: gc.relocate			; CHECK: gc.relocate
	; CHECK: gc.relocate			; CHECK: gc.relocate
	%landing_pad = landingpad { i8, i32 } personality i32 () @"personality_function"			%landing_pad = landingpad { i8, i32 } personality i32 () @"personality_function"
	cleanup			cleanup
	%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1			%relocate_token = extractvalue { i8*, i32 } %landing_pad, 1
	%obj.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 10, i32 10)			%obj.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 12, i32 12)
	%obj1.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 10, i32 10)			%obj1.relocated1 = call coldcc i8 addrspace(1)* @llvm.experimental.gc.relocate.p1i8(i32 %relocate_token, i32 12, i32 12)
	ret i8 addrspace(1)* %obj1.relocated1			ret i8 addrspace(1)* %obj1.relocated1
	}			}

This is an archive of the discontinued LLVM Phabricator instance.

[Statepoints] Support for "patchable" statepoints.ClosedPublic

Details

Diff Detail

Event Timeline

Revision Contents

Diff 25648

llvm/trunk/docs/Statepoints.rst

llvm/trunk/include/llvm/CodeGen/StackMaps.h

llvm/trunk/include/llvm/IR/IRBuilder.h

llvm/trunk/include/llvm/IR/Intrinsics.td

llvm/trunk/include/llvm/IR/Statepoint.h

llvm/trunk/lib/CodeGen/SelectionDAG/StatepointLowering.cpp

llvm/trunk/lib/CodeGen/StackMaps.cpp

llvm/trunk/lib/IR/IRBuilder.cpp

llvm/trunk/lib/IR/Verifier.cpp

llvm/trunk/lib/Target/X86/X86MCInstLower.cpp

llvm/trunk/lib/Transforms/Scalar/PlaceSafepoints.cpp

llvm/trunk/test/Analysis/ValueTracking/memory-dereferenceable.ll

llvm/trunk/test/CodeGen/Generic/overloaded-intrinsic-name.ll

llvm/trunk/test/CodeGen/X86/statepoint-allocas.ll

llvm/trunk/test/CodeGen/X86/statepoint-call-lowering.ll

llvm/trunk/test/CodeGen/X86/statepoint-forward.ll

llvm/trunk/test/CodeGen/X86/statepoint-gctransition-call-lowering.ll

llvm/trunk/test/CodeGen/X86/statepoint-invoke.ll

llvm/trunk/test/CodeGen/X86/statepoint-stack-usage.ll

llvm/trunk/test/CodeGen/X86/statepoint-stackmap-format.ll

llvm/trunk/test/Transforms/CodeGenPrepare/statepoint-relocate.ll

llvm/trunk/test/Transforms/InstCombine/gc.relocate.ll

llvm/trunk/test/Transforms/InstCombine/statepoint.ll

llvm/trunk/test/Transforms/PlaceSafepoints/basic.ll

llvm/trunk/test/Transforms/PlaceSafepoints/call-in-loop.ll

llvm/trunk/test/Transforms/PlaceSafepoints/finite-loops.ll

llvm/trunk/test/Transforms/PlaceSafepoints/invokes.ll

llvm/trunk/test/Transforms/PlaceSafepoints/split-backedge.ll

llvm/trunk/test/Transforms/PlaceSafepoints/statepoint-frameescape.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-1.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-10.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-11.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-2.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-3.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-4.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-5.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-6.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-7.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-8.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers-9.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/base-pointers.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/basics.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/constants.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/gc_relocate_creation.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/live-vector.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/liveness-basics.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/preprocess.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocate_invoke_result.ll

llvm/trunk/test/Transforms/RewriteStatepointsForGC/relocation.ll

llvm/trunk/test/Verifier/invalid-patchable-statepoint.ll

llvm/trunk/test/Verifier/invalid-statepoint.ll

llvm/trunk/test/Verifier/invalid-statepoint2.ll

llvm/trunk/test/Verifier/statepoint.ll

[Statepoints] Support for "patchable" statepoints.
ClosedPublic