6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-07-21 18:29:45 +00:00
Code Issues Projects Releases Wiki Activity

Use ImmutableCallSite for statepoint verification.

Browse Source 
Patch by: Igor Laevsky

"This change generalizes statepoint verification to use ImmutableCallSite instead of CallInst. This will allow to easily implement invoke statepoint verification (in a following change)."

Differential Revision: http://reviews.llvm.org/D7308



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@228064 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Philip Reames 2015-02-03 23:18:47 +00:00
parent 6daac09e80
commit c81fa9543f
1 changed files with 20 additions and 17 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/IR/Verifier.cpp
View File

@ -370,7 +370,7 @@ private:
const Value *V);
void VerifyConstantExprBitcastType(const ConstantExpr *CE);
void VerifyStatepoint(CallInst &CI);
void VerifyStatepoint(ImmutableCallSite CS);
};
class DebugInfoVerifier : public VerifierSupport {
public:
@ -1047,26 +1047,26 @@ bool Verifier::VerifyAttributeCount(AttributeSet Attrs, unsigned Params) {
}
/// \brief Verify that statepoint intrinsic is well formed.
void Verifier::VerifyStatepoint(CallInst &CI) {
assert(CI.getCalledFunction() &&
CI.getCalledFunction()->getIntrinsicID() ==
Intrinsic::experimental_gc_statepoint);
void Verifier::VerifyStatepoint(ImmutableCallSite CS) {
assert(CS.getCalledFunction() &&
CS.getCalledFunction()->getIntrinsicID() ==
Intrinsic::experimental_gc_statepoint);
Assert1(!CI.doesNotAccessMemory() &&
!CI.onlyReadsMemory(),
const Instruction &CI = *CS.getInstruction();
Assert1(!CS.doesNotAccessMemory() &&
!CS.onlyReadsMemory(),
"gc.statepoint must read and write memory to preserve "
"reordering restrictions required by safepoint semantics", &CI);
Assert1(!CI.isInlineAsm(),
"gc.statepoint support for inline assembly unimplemented", &CI);
const Value *Target = CI.getArgOperand(0);
const Value *Target = CS.getArgument(0);
const PointerType *PT = dyn_cast<PointerType>(Target->getType());
Assert2(PT && PT->getElementType()->isFunctionTy(),
"gc.statepoint callee must be of function pointer type",
&CI, Target);
FunctionType *TargetFuncType = cast<FunctionType>(PT->getElementType());
const Value *NumCallArgsV = CI.getArgOperand(1);
const Value *NumCallArgsV = CS.getArgument(1);
Assert1(isa<ConstantInt>(NumCallArgsV),
"gc.statepoint number of arguments to underlying call "
"must be constant integer", &CI);
@ -1087,7 +1087,7 @@ void Verifier::VerifyStatepoint(CallInst &CI) {
Assert1(NumCallArgs == NumParams,
"gc.statepoint mismatch in number of call args", &CI);
const Value *Unused = CI.getArgOperand(2);
const Value *Unused = CS.getArgument(2);
Assert1(isa<ConstantInt>(Unused) &&
cast<ConstantInt>(Unused)->isNullValue(),
"gc.statepoint parameter #3 must be zero", &CI);
@ -1096,13 +1096,13 @@ void Verifier::VerifyStatepoint(CallInst &CI) {
// the type of the wrapped callee.
for (int i = 0; i < NumParams; i++) {
Type *ParamType = TargetFuncType->getParamType(i);
Type *ArgType = CI.getArgOperand(3+i)->getType();
Type *ArgType = CS.getArgument(3+i)->getType();
Assert1(ArgType == ParamType,
"gc.statepoint call argument does not match wrapped "
"function type", &CI);
}
const int EndCallArgsInx = 2+NumCallArgs;
const Value *NumDeoptArgsV = CI.getArgOperand(EndCallArgsInx+1);
const Value *NumDeoptArgsV = CS.getArgument(EndCallArgsInx+1);
Assert1(isa<ConstantInt>(NumDeoptArgsV),
"gc.statepoint number of deoptimization arguments "
"must be constant integer", &CI);
@ -1111,13 +1111,13 @@ void Verifier::VerifyStatepoint(CallInst &CI) {
"gc.statepoint number of deoptimization arguments "
"must be positive", &CI);
Assert1(4 + NumCallArgs + NumDeoptArgs <= (int)CI.getNumArgOperands(),
Assert1(4 + NumCallArgs + NumDeoptArgs <= (int)CS.arg_size(),
"gc.statepoint too few arguments according to length fields", &CI);
// 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
// of the same statepoint sequence
for (User *U : CI.users()) {
for (const User *U : CI.users()) {
const CallInst *Call = dyn_cast<const CallInst>(U);
Assert2(Call, "illegal use of statepoint token", &CI, U);
if (!Call) continue;
@ -2727,7 +2727,10 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
}
case Intrinsic::experimental_gc_statepoint:
VerifyStatepoint(CI);
Assert1(!CI.isInlineAsm(),
"gc.statepoint support for inline assembly unimplemented", &CI);
VerifyStatepoint(ImmutableCallSite(&CI));
break;
case Intrinsic::experimental_gc_result_int:
case Intrinsic::experimental_gc_result_float: