+ case Intrinsic::prefetch:
+ Assert1(isa<ConstantInt>(CI.getOperand(2)) &&
+ isa<ConstantInt>(CI.getOperand(3)) &&
+ cast<ConstantInt>(CI.getOperand(2))->getZExtValue() < 2 &&
+ cast<ConstantInt>(CI.getOperand(3))->getZExtValue() < 4,
+ "invalid arguments to llvm.prefetch",
+ &CI);
+ break;
+ case Intrinsic::stackprotector:
+ Assert1(isa<AllocaInst>(CI.getOperand(2)->stripPointerCasts()),
+ "llvm.stackprotector parameter #2 must resolve to an alloca.",
+ &CI);
+ break;
+ }
+}
+
+/// Produce a string to identify an intrinsic parameter or return value.
+/// The ArgNo value numbers the return values from 0 to NumRets-1 and the
+/// parameters beginning with NumRets.
+///
+static std::string IntrinsicParam(unsigned ArgNo, unsigned NumRets) {
+ if (ArgNo < NumRets) {
+ if (NumRets == 1)
+ return "Intrinsic result type";
+ else
+ return "Intrinsic result type #" + utostr(ArgNo);
+ } else
+ return "Intrinsic parameter #" + utostr(ArgNo - NumRets);
+}
+
+bool Verifier::PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty,
+ int VT, unsigned ArgNo, std::string &Suffix) {
+ const FunctionType *FTy = F->getFunctionType();
+
+ unsigned NumElts = 0;
+ const Type *EltTy = Ty;
+ const VectorType *VTy = dyn_cast<VectorType>(Ty);
+ if (VTy) {
+ EltTy = VTy->getElementType();
+ NumElts = VTy->getNumElements();
+ }
+
+ const Type *RetTy = FTy->getReturnType();
+ const StructType *ST = dyn_cast<StructType>(RetTy);
+ unsigned NumRets = 1;
+ if (ST)
+ NumRets = ST->getNumElements();
+
+ if (VT < 0) {
+ int Match = ~VT;
+
+ // Check flags that indicate a type that is an integral vector type with
+ // elements that are larger or smaller than the elements of the matched
+ // type.
+ if ((Match & (ExtendedElementVectorType |
+ TruncatedElementVectorType)) != 0) {
+ const IntegerType *IEltTy = dyn_cast<IntegerType>(EltTy);
+ if (!VTy || !IEltTy) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "an integral vector type.", F);
+ return false;
+ }
+ // Adjust the current Ty (in the opposite direction) rather than
+ // the type being matched against.
+ if ((Match & ExtendedElementVectorType) != 0) {
+ if ((IEltTy->getBitWidth() & 1) != 0) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " vector "
+ "element bit-width is odd.", F);
+ return false;
+ }
+ Ty = VectorType::getTruncatedElementVectorType(VTy);
+ } else
+ Ty = VectorType::getExtendedElementVectorType(VTy);
+ Match &= ~(ExtendedElementVectorType | TruncatedElementVectorType);
+ }
+
+ if (Match <= static_cast<int>(NumRets - 1)) {
+ if (ST)
+ RetTy = ST->getElementType(Match);
+
+ if (Ty != RetTy) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
+ "match return type.", F);
+ return false;
+ }
+ } else {
+ if (Ty != FTy->getParamType(Match - 1)) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " does not "
+ "match parameter %" + utostr(Match - 1) + ".", F);
+ return false;
+ }
+ }
+ } else if (VT == MVT::iAny) {
+ if (!EltTy->isInteger()) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "an integer type.", F);
+ return false;
+ }
+
+ unsigned GotBits = cast<IntegerType>(EltTy)->getBitWidth();
+ Suffix += ".";
+
+ if (EltTy != Ty)
+ Suffix += "v" + utostr(NumElts);
+
+ Suffix += "i" + utostr(GotBits);;
+
+ // Check some constraints on various intrinsics.
+ switch (ID) {
+ default: break; // Not everything needs to be checked.
+ case Intrinsic::bswap:
+ if (GotBits < 16 || GotBits % 16 != 0) {
+ CheckFailed("Intrinsic requires even byte width argument", F);
+ return false;
+ }
+ break;
+ }
+ } else if (VT == MVT::fAny) {
+ if (!EltTy->isFloatingPoint()) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not "
+ "a floating-point type.", F);
+ return false;
+ }
+
+ Suffix += ".";
+
+ if (EltTy != Ty)
+ Suffix += "v" + utostr(NumElts);
+
+ Suffix += MVT::getMVT(EltTy).getMVTString();
+ } else if (VT == MVT::iPTR) {
+ if (!isa<PointerType>(Ty)) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
+ "pointer and a pointer is required.", F);
+ return false;
+ }
+ } else if (VT == MVT::iPTRAny) {
+ // Outside of TableGen, we don't distinguish iPTRAny (to any address space)
+ // and iPTR. In the verifier, we can not distinguish which case we have so
+ // allow either case to be legal.
+ if (const PointerType* PTyp = dyn_cast<PointerType>(Ty)) {
+ Suffix += ".p" + utostr(PTyp->getAddressSpace()) +
+ MVT::getMVT(PTyp->getElementType()).getMVTString();
+ } else {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is not a "
+ "pointer and a pointer is required.", F);
+ return false;
+ }
+ } else if (MVT((MVT::SimpleValueType)VT).isVector()) {
+ MVT VVT = MVT((MVT::SimpleValueType)VT);
+
+ // If this is a vector argument, verify the number and type of elements.
+ if (VVT.getVectorElementType() != MVT::getMVT(EltTy)) {
+ CheckFailed("Intrinsic prototype has incorrect vector element type!", F);
+ return false;
+ }
+
+ if (VVT.getVectorNumElements() != NumElts) {
+ CheckFailed("Intrinsic prototype has incorrect number of "
+ "vector elements!", F);
+ return false;
+ }
+ } else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is wrong!", F);
+ return false;
+ } else if (EltTy != Ty) {
+ CheckFailed(IntrinsicParam(ArgNo, NumRets) + " is a vector "
+ "and a scalar is required.", F);
+ return false;