InstsInThisBlock.insert(&I);
}
-static bool HasPtrPtrType(Value *Val) {
- if (const PointerType *PtrTy = dyn_cast<PointerType>(Val->getType()))
- return isa<PointerType>(PtrTy->getElementType());
- return false;
-}
-
/// visitIntrinsicFunction - Allow intrinsics to be verified in different ways.
///
void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) {
switch (ID) {
default:
break;
- case Intrinsic::gcroot:
- Assert1(HasPtrPtrType(CI.getOperand(1)),
- "llvm.gcroot parameter #1 must be a pointer to a pointer.", &CI);
- Assert1(isa<AllocaInst>(IntrinsicInst::StripPointerCasts(CI.getOperand(1))),
- "llvm.gcroot parameter #1 must be an alloca (or a bitcast of one).",
- &CI);
- Assert1(isa<Constant>(CI.getOperand(2)),
- "llvm.gcroot parameter #2 must be a constant.", &CI);
- break;
- case Intrinsic::gcwrite:
- Assert1(CI.getOperand(3)->getType()
- == PointerType::getUnqual(CI.getOperand(1)->getType()),
- "Call to llvm.gcwrite must be with type 'void (%ty*, %ty2*, %ty**)'.",
- &CI);
- break;
- case Intrinsic::gcread:
- Assert1(CI.getOperand(2)->getType() == PointerType::getUnqual(CI.getType()),
- "Call to llvm.gcread must be with type '%ty* (%ty2*, %ty**).'",
- &CI);
- break;
+ case Intrinsic::gcroot: {
+ Type *PtrTy = PointerType::getUnqual(Type::Int8Ty),
+ *PtrPtrTy = PointerType::getUnqual(PtrTy);
+ Assert1(CI.getOperand(1)->getType() == PtrPtrTy,
+ "Intrinsic parameter #1 is not i8**.", &CI);
+ Assert1(CI.getOperand(2)->getType() == PtrTy,
+ "Intrinsic parameter #2 is not i8*.", &CI);
+ Assert1(
+ isa<AllocaInst>(IntrinsicInst::StripPointerCasts(CI.getOperand(1))),
+ "llvm.gcroot parameter #1 must be an alloca.",
+ &CI);
+ Assert1(isa<Constant>(CI.getOperand(2)),
+ "llvm.gcroot parameter #2 must be a constant.", &CI);
+ } break;
+ case Intrinsic::gcwrite: {
+ Type *PtrTy = PointerType::getUnqual(Type::Int8Ty),
+ *PtrPtrTy = PointerType::getUnqual(PtrTy);
+ Assert1(CI.getOperand(1)->getType() == PtrTy,
+ "Intrinsic parameter #1 is not a i8*.", &CI);
+ Assert1(CI.getOperand(2)->getType() == PtrTy,
+ "Intrinsic parameter #2 is not a i8*.", &CI);
+ Assert1(CI.getOperand(3)->getType() == PtrPtrTy,
+ "Intrinsic parameter #3 is not a i8**.", &CI);
+ } break;
+ case Intrinsic::gcread: {
+ Type *PtrTy = PointerType::getUnqual(Type::Int8Ty),
+ *PtrPtrTy = PointerType::getUnqual(PtrTy);
+ Assert1(CI.getOperand(1)->getType() == PtrTy,
+ "Intrinsic parameter #1 is not a i8*.", &CI);
+ Assert1(CI.getOperand(2)->getType() == PtrPtrTy,
+ "Intrinsic parameter #2 is not a i8**.", &CI);
+ } break;
case Intrinsic::init_trampoline:
Assert1(isa<Function>(IntrinsicInst::StripPointerCasts(CI.getOperand(2))),
"llvm.init_trampoline parameter #2 must resolve to a function.",
&CI);
+ break;
}
}
--- /dev/null
+; RUN: not llvm-as < %s
+
+ %list = type { i32, %list* }
+
+; This usage is invalid now; instead, objects must be bitcast to i8* for input
+; to the gc intrinsics.
+declare void @llvm.gcwrite(%list*, %list*, %list**)
+
+define %list* @cons(i32 %hd, %list* %tl) gc "example" {
+ %tmp = call i8* @gcalloc(i32 bitcast(%list* getelementptr(%list* null, i32 1) to i32))
+ %cell = bitcast i8* %tmp to %list*
+
+ %hd.ptr = getelementptr %list* %cell, i32 0, i32 0
+ store i32 %hd, i32* %hd.ptr
+
+ %tl.ptr = getelementptr %list* %cell, i32 0, i32 0
+ call void @llvm.gcwrite(%list* %tl, %list* %cell, %list** %tl.ptr)
+
+ ret %cell.2
+}
+
+declare i8* @gcalloc(i32)