X-Git-Url: http://demsky.eecs.uci.edu/git/?a=blobdiff_plain;f=lib%2FVMCore%2FVerifier.cpp;h=10816e6248bce95c3b4ec9199be2d2ddd7200185;hb=baeb911d60401818dc9fe0db6182cd048e4fdd03;hp=af11fce5e7237ab52a4a2a7f16a0ddd97bf6e983;hpb=f72fb679eff7de84e3e18b75d63a18cb3510bcdd;p=oota-llvm.git diff --git a/lib/VMCore/Verifier.cpp b/lib/VMCore/Verifier.cpp index af11fce5e72..10816e6248b 100644 --- a/lib/VMCore/Verifier.cpp +++ b/lib/VMCore/Verifier.cpp @@ -45,6 +45,7 @@ #include "llvm/DerivedTypes.h" #include "llvm/InlineAsm.h" #include "llvm/IntrinsicInst.h" +#include "llvm/MDNode.h" #include "llvm/Module.h" #include "llvm/ModuleProvider.h" #include "llvm/Pass.h" @@ -61,6 +62,7 @@ #include "llvm/ADT/StringExtras.h" #include "llvm/ADT/STLExtras.h" #include "llvm/Support/Compiler.h" +#include "llvm/Support/raw_ostream.h" #include #include #include @@ -72,6 +74,10 @@ namespace { // Anonymous namespace for class PreVerifier() : FunctionPass(&ID) { } + virtual void getAnalysisUsage(AnalysisUsage &AU) const { + AU.setPreservesAll(); + } + // Check that the prerequisites for successful DominatorTree construction // are satisfied. bool runOnFunction(Function &F) { @@ -212,7 +218,7 @@ namespace { return false; case ReturnStatusAction: msgs << "compilation terminated.\n"; - return Broken; + return true; } } @@ -266,11 +272,13 @@ namespace { void visitInsertValueInst(InsertValueInst &IVI); void VerifyCallSite(CallSite CS); + bool PerformTypeCheck(Intrinsic::ID ID, Function *F, const Type *Ty, + int VT, unsigned ArgNo, std::string &Suffix); void VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, - unsigned Count, ...); - void VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, - bool isReturnValue, const Value *V); - void VerifyFunctionAttrs(const FunctionType *FT, const PAListPtr &Attrs, + unsigned RetNum, unsigned ParamNum, ...); + void VerifyParameterAttrs(Attributes Attrs, const Type *Ty, + bool isReturnValue, const Value *V); + void VerifyFunctionAttrs(const FunctionType *FT, const AttrListPtr &Attrs, const Value *V); void WriteValue(const Value *V) { @@ -284,8 +292,10 @@ namespace { } void WriteType(const Type *T) { - if ( !T ) return; - WriteTypeSymbolic(msgs, T, Mod ); + if (!T) return; + raw_os_ostream RO(msgs); + RO << ' '; + WriteTypeSymbolic(RO, T, Mod); } @@ -329,7 +339,6 @@ static RegisterPass X("verify", "Module Verifier"); #define Assert4(C, M, V1, V2, V3, V4) \ do { if (!(C)) { CheckFailed(M, V1, V2, V3, V4); return; } } while (0) - void Verifier::visit(Instruction &I) { for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) Assert1(I.getOperand(i) != 0, "Operand is null", &I); @@ -344,7 +353,7 @@ void Verifier::visitGlobalValue(GlobalValue &GV) { GV.hasExternalWeakLinkage() || GV.hasGhostLinkage() || (isa(GV) && - (GV.hasInternalLinkage() || GV.hasWeakLinkage())), + (GV.hasLocalLinkage() || GV.hasWeakLinkage())), "Global is external, but doesn't have external or dllimport or weak linkage!", &GV); @@ -366,6 +375,28 @@ void Verifier::visitGlobalVariable(GlobalVariable &GV) { Assert1(GV.getInitializer()->getType() == GV.getType()->getElementType(), "Global variable initializer type does not match global " "variable type!", &GV); + + // Verify that any metadata used in a global initializer points only to + // other globals. + if (MDNode *FirstNode = dyn_cast(GV.getInitializer())) { + SmallVector NodesToAnalyze; + NodesToAnalyze.push_back(FirstNode); + while (!NodesToAnalyze.empty()) { + const MDNode *N = NodesToAnalyze.back(); + NodesToAnalyze.pop_back(); + + for (MDNode::const_elem_iterator I = N->elem_begin(), + E = N->elem_end(); I != E; ++I) + if (const Value *V = *I) { + if (const MDNode *Next = dyn_cast(V)) + NodesToAnalyze.push_back(Next); + else + Assert3(isa(V), + "reference to instruction from global metadata node", + &GV, N, V); + } + } + } } else { Assert1(GV.hasExternalLinkage() || GV.hasDLLImportLinkage() || GV.hasExternalWeakLinkage(), @@ -378,7 +409,7 @@ void Verifier::visitGlobalVariable(GlobalVariable &GV) { void Verifier::visitGlobalAlias(GlobalAlias &GA) { Assert1(!GA.getName().empty(), "Alias name cannot be empty!", &GA); - Assert1(GA.hasExternalLinkage() || GA.hasInternalLinkage() || + Assert1(GA.hasExternalLinkage() || GA.hasLocalLinkage() || GA.hasWeakLinkage(), "Alias should have external or external weak linkage!", &GA); Assert1(GA.getAliasee(), @@ -388,13 +419,15 @@ void Verifier::visitGlobalAlias(GlobalAlias &GA) { if (!isa(GA.getAliasee())) { const ConstantExpr *CE = dyn_cast(GA.getAliasee()); - Assert1(CE && CE->getOpcode() == Instruction::BitCast && + Assert1(CE && + (CE->getOpcode() == Instruction::BitCast || + CE->getOpcode() == Instruction::GetElementPtr) && isa(CE->getOperand(0)), "Aliasee should be either GlobalValue or bitcast of GlobalValue", &GA); } - const GlobalValue* Aliasee = GA.resolveAliasedGlobal(); + const GlobalValue* Aliasee = GA.resolveAliasedGlobal(/*stopOnWeak*/ false); Assert1(Aliasee, "Aliasing chain should end with function or global variable", &GA); @@ -404,42 +437,42 @@ void Verifier::visitGlobalAlias(GlobalAlias &GA) { void Verifier::verifyTypeSymbolTable(TypeSymbolTable &ST) { } -// VerifyAttrs - Check the given parameter attributes for an argument or return +// VerifyParameterAttrs - Check the given attributes for an argument or return // value of the specified type. The value V is printed in error messages. -void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, - bool isReturnValue, const Value *V) { - if (Attrs == ParamAttr::None) +void Verifier::VerifyParameterAttrs(Attributes Attrs, const Type *Ty, + bool isReturnValue, const Value *V) { + if (Attrs == Attribute::None) return; + Attributes FnCheckAttr = Attrs & Attribute::FunctionOnly; + Assert1(!FnCheckAttr, "Attribute " + Attribute::getAsString(FnCheckAttr) + + " only applies to the function!", V); + if (isReturnValue) { - ParameterAttributes RetI = Attrs & ParamAttr::ParameterOnly; - Assert1(!RetI, "Attribute " + ParamAttr::getAsString(RetI) + + Attributes RetI = Attrs & Attribute::ParameterOnly; + Assert1(!RetI, "Attribute " + Attribute::getAsString(RetI) + " does not apply to return values!", V); - } else { - ParameterAttributes ParmI = Attrs & ParamAttr::ReturnOnly; - Assert1(!ParmI, "Attribute " + ParamAttr::getAsString(ParmI) + - " only applies to return values!", V); } for (unsigned i = 0; - i < array_lengthof(ParamAttr::MutuallyIncompatible); ++i) { - ParameterAttributes MutI = Attrs & ParamAttr::MutuallyIncompatible[i]; + i < array_lengthof(Attribute::MutuallyIncompatible); ++i) { + Attributes MutI = Attrs & Attribute::MutuallyIncompatible[i]; Assert1(!(MutI & (MutI - 1)), "Attributes " + - ParamAttr::getAsString(MutI) + " are incompatible!", V); + Attribute::getAsString(MutI) + " are incompatible!", V); } - ParameterAttributes TypeI = Attrs & ParamAttr::typeIncompatible(Ty); + Attributes TypeI = Attrs & Attribute::typeIncompatible(Ty); Assert1(!TypeI, "Wrong type for attribute " + - ParamAttr::getAsString(TypeI), V); + Attribute::getAsString(TypeI), V); - ParameterAttributes ByValI = Attrs & ParamAttr::ByVal; + Attributes ByValI = Attrs & Attribute::ByVal; if (const PointerType *PTy = dyn_cast(Ty)) { Assert1(!ByValI || PTy->getElementType()->isSized(), - "Attribute " + ParamAttr::getAsString(ByValI) + + "Attribute " + Attribute::getAsString(ByValI) + " does not support unsized types!", V); } else { Assert1(!ByValI, - "Attribute " + ParamAttr::getAsString(ByValI) + + "Attribute " + Attribute::getAsString(ByValI) + " only applies to parameters with pointer type!", V); } } @@ -447,7 +480,7 @@ void Verifier::VerifyAttrs(ParameterAttributes Attrs, const Type *Ty, // VerifyFunctionAttrs - Check parameter attributes against a function type. // The value V is printed in error messages. void Verifier::VerifyFunctionAttrs(const FunctionType *FT, - const PAListPtr &Attrs, + const AttrListPtr &Attrs, const Value *V) { if (Attrs.isEmpty()) return; @@ -455,7 +488,7 @@ void Verifier::VerifyFunctionAttrs(const FunctionType *FT, bool SawNest = false; for (unsigned i = 0, e = Attrs.getNumSlots(); i != e; ++i) { - const ParamAttrsWithIndex &Attr = Attrs.getSlot(i); + const AttributeWithIndex &Attr = Attrs.getSlot(i); const Type *Ty; if (Attr.Index == 0) @@ -463,20 +496,45 @@ void Verifier::VerifyFunctionAttrs(const FunctionType *FT, else if (Attr.Index-1 < FT->getNumParams()) Ty = FT->getParamType(Attr.Index-1); else - break; // VarArgs attributes, don't verify. - - VerifyAttrs(Attr.Attrs, Ty, Attr.Index == 0, V); + break; // VarArgs attributes, verified elsewhere. + + VerifyParameterAttrs(Attr.Attrs, Ty, Attr.Index == 0, V); - if (Attr.Attrs & ParamAttr::Nest) { + if (Attr.Attrs & Attribute::Nest) { Assert1(!SawNest, "More than one parameter has attribute nest!", V); SawNest = true; } - if (Attr.Attrs & ParamAttr::StructRet) + if (Attr.Attrs & Attribute::StructRet) Assert1(Attr.Index == 1, "Attribute sret not on first parameter!", V); } + + Attributes FAttrs = Attrs.getFnAttributes(); + Attributes NotFn = FAttrs & (~Attribute::FunctionOnly); + Assert1(!NotFn, "Attribute " + Attribute::getAsString(NotFn) + + " does not apply to the function!", V); + + for (unsigned i = 0; + i < array_lengthof(Attribute::MutuallyIncompatible); ++i) { + Attributes MutI = FAttrs & Attribute::MutuallyIncompatible[i]; + Assert1(!(MutI & (MutI - 1)), "Attributes " + + Attribute::getAsString(MutI) + " are incompatible!", V); + } } +static bool VerifyAttributeCount(const AttrListPtr &Attrs, unsigned Params) { + if (Attrs.isEmpty()) + return true; + + unsigned LastSlot = Attrs.getNumSlots() - 1; + unsigned LastIndex = Attrs.getSlot(LastSlot).Index; + if (LastIndex <= Params + || (LastIndex == (unsigned)~0 + && (LastSlot == 0 || Attrs.getSlot(LastSlot - 1).Index <= Params))) + return true; + + return false; +} // visitFunction - Verify that a function is ok. // void Verifier::visitFunction(Function &F) { @@ -495,10 +553,9 @@ void Verifier::visitFunction(Function &F) { Assert1(!F.hasStructRetAttr() || F.getReturnType() == Type::VoidTy, "Invalid struct return type!", &F); - const PAListPtr &Attrs = F.getParamAttrs(); + const AttrListPtr &Attrs = F.getAttributes(); - Assert1(Attrs.isEmpty() || - Attrs.getSlot(Attrs.getNumSlots()-1).Index <= FT->getNumParams(), + Assert1(VerifyAttributeCount(Attrs, FT->getNumParams()), "Attributes after last parameter!", &F); // Check function attributes. @@ -509,7 +566,6 @@ void Verifier::visitFunction(Function &F) { default: break; case CallingConv::C: - case CallingConv::X86_SSECall: break; case CallingConv::Fast: case CallingConv::Cold: @@ -519,6 +575,12 @@ void Verifier::visitFunction(Function &F) { break; } + bool isLLVMdotName = F.getName().size() >= 5 && + F.getName().substr(0, 5) == "llvm."; + if (!isLLVMdotName) + Assert1(F.getReturnType() != Type::MetadataTy, + "Function may not return metadata unless it's an intrinsic", &F); + // Check that the argument values match the function type for this function... unsigned i = 0; for (Function::arg_iterator I = F.arg_begin(), E = F.arg_end(); @@ -528,6 +590,9 @@ void Verifier::visitFunction(Function &F) { I, FT->getParamType(i)); Assert1(I->getType()->isFirstClassType(), "Function arguments must have first-class types!", I); + if (!isLLVMdotName) + Assert2(I->getType() != Type::MetadataTy, + "Function takes metadata but isn't an intrinsic", I, &F); } if (F.isDeclaration()) { @@ -537,9 +602,7 @@ void Verifier::visitFunction(Function &F) { } else { // Verify that this function (which has a body) is not named "llvm.*". It // is not legal to define intrinsics. - if (F.getName().size() >= 5) - Assert1(F.getName().substr(0, 5) != "llvm.", - "llvm intrinsics cannot be defined!", &F); + Assert1(!isLLVMdotName, "llvm intrinsics cannot be defined!", &F); // Check the entry node BasicBlock *Entry = &F.getEntryBlock(); @@ -615,7 +678,7 @@ void Verifier::visitReturnInst(ReturnInst &RI) { unsigned N = RI.getNumOperands(); if (F->getReturnType() == Type::VoidTy) Assert2(N == 0, - "Found return instr that returns void in Function of non-void " + "Found return instr that returns non-void in Function of void " "return type!", &RI, F->getReturnType()); else if (N == 1 && F->getReturnType() == RI.getOperand(0)->getType()) { // Exactly one return value and it matches the return type. Good. @@ -659,23 +722,10 @@ void Verifier::visitSwitchInst(SwitchInst &SI) { } void Verifier::visitSelectInst(SelectInst &SI) { - if (const VectorType* vt - = dyn_cast(SI.getCondition()->getType())) { - Assert1( vt->getElementType() == Type::Int1Ty, - "Select condition type must be vector of bool!", &SI); - if (const VectorType* val_vt - = dyn_cast(SI.getTrueValue()->getType())) { - Assert1( vt->getNumElements() == val_vt->getNumElements(), - "Select vector size != value vector size", &SI); - } else { - Assert1(0, "Vector select values must have vector types", &SI); - } - } else { - Assert1(SI.getCondition()->getType() == Type::Int1Ty, - "Select condition type must be bool!", &SI); - } - Assert1(SI.getTrueValue()->getType() == SI.getFalseValue()->getType(), - "Select values must have identical types!", &SI); + Assert1(!SelectInst::areInvalidOperands(SI.getOperand(0), SI.getOperand(1), + SI.getOperand(2)), + "Invalid operands for select instruction!", &SI); + Assert1(SI.getTrueValue()->getType() == SI.getType(), "Select values must have same type as select instruction!", &SI); visitInstruction(SI); @@ -695,11 +745,13 @@ void Verifier::visitTruncInst(TruncInst &I) { const Type *DestTy = I.getType(); // Get the size of the types in bits, we'll need this later - unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); - unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); + unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); + unsigned DestBitSize = DestTy->getScalarSizeInBits(); Assert1(SrcTy->isIntOrIntVector(), "Trunc only operates on integer", &I); Assert1(DestTy->isIntOrIntVector(), "Trunc only produces integer", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "trunc source and destination must both be a vector or neither", &I); Assert1(SrcBitSize > DestBitSize,"DestTy too big for Trunc", &I); visitInstruction(I); @@ -713,8 +765,10 @@ void Verifier::visitZExtInst(ZExtInst &I) { // Get the size of the types in bits, we'll need this later Assert1(SrcTy->isIntOrIntVector(), "ZExt only operates on integer", &I); Assert1(DestTy->isIntOrIntVector(), "ZExt only produces an integer", &I); - unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); - unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); + Assert1(isa(SrcTy) == isa(DestTy), + "zext source and destination must both be a vector or neither", &I); + unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); + unsigned DestBitSize = DestTy->getScalarSizeInBits(); Assert1(SrcBitSize < DestBitSize,"Type too small for ZExt", &I); @@ -727,11 +781,13 @@ void Verifier::visitSExtInst(SExtInst &I) { const Type *DestTy = I.getType(); // Get the size of the types in bits, we'll need this later - unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); - unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); + unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); + unsigned DestBitSize = DestTy->getScalarSizeInBits(); Assert1(SrcTy->isIntOrIntVector(), "SExt only operates on integer", &I); Assert1(DestTy->isIntOrIntVector(), "SExt only produces an integer", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "sext source and destination must both be a vector or neither", &I); Assert1(SrcBitSize < DestBitSize,"Type too small for SExt", &I); visitInstruction(I); @@ -742,11 +798,13 @@ void Verifier::visitFPTruncInst(FPTruncInst &I) { const Type *SrcTy = I.getOperand(0)->getType(); const Type *DestTy = I.getType(); // Get the size of the types in bits, we'll need this later - unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); - unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); + unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); + unsigned DestBitSize = DestTy->getScalarSizeInBits(); Assert1(SrcTy->isFPOrFPVector(),"FPTrunc only operates on FP", &I); Assert1(DestTy->isFPOrFPVector(),"FPTrunc only produces an FP", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "fptrunc source and destination must both be a vector or neither",&I); Assert1(SrcBitSize > DestBitSize,"DestTy too big for FPTrunc", &I); visitInstruction(I); @@ -758,11 +816,13 @@ void Verifier::visitFPExtInst(FPExtInst &I) { const Type *DestTy = I.getType(); // Get the size of the types in bits, we'll need this later - unsigned SrcBitSize = SrcTy->getPrimitiveSizeInBits(); - unsigned DestBitSize = DestTy->getPrimitiveSizeInBits(); + unsigned SrcBitSize = SrcTy->getScalarSizeInBits(); + unsigned DestBitSize = DestTy->getScalarSizeInBits(); Assert1(SrcTy->isFPOrFPVector(),"FPExt only operates on FP", &I); Assert1(DestTy->isFPOrFPVector(),"FPExt only produces an FP", &I); + Assert1(isa(SrcTy) == isa(DestTy), + "fpext source and destination must both be a vector or neither", &I); Assert1(SrcBitSize < DestBitSize,"DestTy too small for FPExt", &I); visitInstruction(I); @@ -953,10 +1013,9 @@ void Verifier::VerifyCallSite(CallSite CS) { "Call parameter type does not match function signature!", CS.getArgument(i), FTy->getParamType(i), I); - const PAListPtr &Attrs = CS.getParamAttrs(); + const AttrListPtr &Attrs = CS.getAttributes(); - Assert1(Attrs.isEmpty() || - Attrs.getSlot(Attrs.getNumSlots()-1).Index <= CS.arg_size(), + Assert1(VerifyAttributeCount(Attrs, CS.arg_size()), "Attributes after last parameter!", I); // Verify call attributes. @@ -965,25 +1024,35 @@ void Verifier::VerifyCallSite(CallSite CS) { if (FTy->isVarArg()) // Check attributes on the varargs part. for (unsigned Idx = 1 + FTy->getNumParams(); Idx <= CS.arg_size(); ++Idx) { - ParameterAttributes Attr = Attrs.getParamAttrs(Idx); + Attributes Attr = Attrs.getParamAttributes(Idx); - VerifyAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I); + VerifyParameterAttrs(Attr, CS.getArgument(Idx-1)->getType(), false, I); - ParameterAttributes VArgI = Attr & ParamAttr::VarArgsIncompatible; - Assert1(!VArgI, "Attribute " + ParamAttr::getAsString(VArgI) + + Attributes VArgI = Attr & Attribute::VarArgsIncompatible; + Assert1(!VArgI, "Attribute " + Attribute::getAsString(VArgI) + " cannot be used for vararg call arguments!", I); } + // Verify that there's no metadata unless it's a direct call to an intrinsic. + if (!CS.getCalledFunction() || CS.getCalledFunction()->getName().size() < 5 || + CS.getCalledFunction()->getName().substr(0, 5) != "llvm.") { + Assert1(FTy->getReturnType() != Type::MetadataTy, + "Only intrinsics may return metadata", I); + for (FunctionType::param_iterator PI = FTy->param_begin(), + PE = FTy->param_end(); PI != PE; ++PI) + Assert1(PI->get() != Type::MetadataTy, "Function has metadata parameter " + "but isn't an intrinsic", I); + } + visitInstruction(*I); } void Verifier::visitCallInst(CallInst &CI) { VerifyCallSite(&CI); - if (Function *F = CI.getCalledFunction()) { + if (Function *F = CI.getCalledFunction()) if (Intrinsic::ID ID = (Intrinsic::ID)F->getIntrinsicID()) visitIntrinsicFunctionCall(ID, CI); - } } void Verifier::visitInvokeInst(InvokeInst &II) { @@ -998,13 +1067,40 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) { "Both operands to a binary operator are not of the same type!", &B); switch (B.getOpcode()) { + // Check that integer arithmetic operators are only used with + // integral operands. + case Instruction::Add: + case Instruction::Sub: + case Instruction::Mul: + case Instruction::SDiv: + case Instruction::UDiv: + case Instruction::SRem: + case Instruction::URem: + Assert1(B.getType()->isIntOrIntVector(), + "Integer arithmetic operators only work with integral types!", &B); + Assert1(B.getType() == B.getOperand(0)->getType(), + "Integer arithmetic operators must have same type " + "for operands and result!", &B); + break; + // Check that floating-point arithmetic operators are only used with + // floating-point operands. + case Instruction::FAdd: + case Instruction::FSub: + case Instruction::FMul: + case Instruction::FDiv: + case Instruction::FRem: + Assert1(B.getType()->isFPOrFPVector(), + "Floating-point arithmetic operators only work with " + "floating-point types!", &B); + Assert1(B.getType() == B.getOperand(0)->getType(), + "Floating-point arithmetic operators must have same type " + "for operands and result!", &B); + break; // Check that logical operators are only used with integral operands. case Instruction::And: case Instruction::Or: case Instruction::Xor: - Assert1(B.getType()->isInteger() || - (isa(B.getType()) && - cast(B.getType())->getElementType()->isInteger()), + Assert1(B.getType()->isIntOrIntVector(), "Logical operators only work with integral types!", &B); Assert1(B.getType() == B.getOperand(0)->getType(), "Logical operators must have same type for operands and result!", @@ -1013,22 +1109,13 @@ void Verifier::visitBinaryOperator(BinaryOperator &B) { case Instruction::Shl: case Instruction::LShr: case Instruction::AShr: - Assert1(B.getType()->isInteger() || - (isa(B.getType()) && - cast(B.getType())->getElementType()->isInteger()), + Assert1(B.getType()->isIntOrIntVector(), "Shifts only work with integral types!", &B); Assert1(B.getType() == B.getOperand(0)->getType(), "Shift return type must be same as operands!", &B); - /* FALL THROUGH */ - default: - // Arithmetic operators only work on integer or fp values - Assert1(B.getType() == B.getOperand(0)->getType(), - "Arithmetic operators must have same type for operands and result!", - &B); - Assert1(B.getType()->isInteger() || B.getType()->isFloatingPoint() || - isa(B.getType()), - "Arithmetic operators must have integer, fp, or vector type!", &B); break; + default: + assert(0 && "Unknown BinaryOperator opcode!"); } visitInstruction(B); @@ -1043,6 +1130,7 @@ void Verifier::visitICmpInst(ICmpInst& IC) { // Check that the operands are the right type Assert1(Op0Ty->isIntOrIntVector() || isa(Op0Ty), "Invalid operand types for ICmp instruction", &IC); + visitInstruction(IC); } @@ -1077,14 +1165,15 @@ void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { Assert1(ShuffleVectorInst::isValidOperands(SV.getOperand(0), SV.getOperand(1), SV.getOperand(2)), "Invalid shufflevector operands!", &SV); - Assert1(SV.getType() == SV.getOperand(0)->getType(), - "Result of shufflevector must match first operand type!", &SV); - + + const VectorType *VTy = dyn_cast(SV.getOperand(0)->getType()); + Assert1(VTy, "Operands are not a vector type", &SV); + // Check to see if Mask is valid. if (const ConstantVector *MV = dyn_cast(SV.getOperand(2))) { for (unsigned i = 0, e = MV->getNumOperands(); i != e; ++i) { if (ConstantInt* CI = dyn_cast(MV->getOperand(i))) { - Assert1(!CI->uge(MV->getNumOperands()*2), + Assert1(!CI->uge(VTy->getNumElements()*2), "Invalid shufflevector shuffle mask!", &SV); } else { Assert1(isa(MV->getOperand(i)), @@ -1096,7 +1185,7 @@ void Verifier::visitShuffleVectorInst(ShuffleVectorInst &SV) { isa(SV.getOperand(2)), "Invalid shufflevector shuffle mask!", &SV); } - + visitInstruction(SV); } @@ -1117,6 +1206,7 @@ void Verifier::visitLoadInst(LoadInst &LI) { cast(LI.getOperand(0)->getType())->getElementType(); Assert2(ElTy == LI.getType(), "Load result type does not match pointer operand type!", &LI, ElTy); + Assert1(ElTy != Type::MetadataTy, "Can't load metadata!", &LI); visitInstruction(LI); } @@ -1125,6 +1215,7 @@ void Verifier::visitStoreInst(StoreInst &SI) { cast(SI.getOperand(1)->getType())->getElementType(); Assert2(ElTy == SI.getOperand(0)->getType(), "Stored value type does not match pointer operand type!", &SI, ElTy); + Assert1(ElTy != Type::MetadataTy, "Can't store metadata!", &SI); visitInstruction(SI); } @@ -1165,8 +1256,7 @@ void Verifier::visitInstruction(Instruction &I) { if (!isa(I)) { // Check that non-phi nodes are not self referential for (Value::use_iterator UI = I.use_begin(), UE = I.use_end(); UI != UE; ++UI) - Assert1(*UI != (User*)&I || - !DT->dominates(&BB->getParent()->getEntryBlock(), BB), + Assert1(*UI != (User*)&I || !DT->isReachableFromEntry(BB), "Only PHI nodes may reference their own value!", &I); } @@ -1186,6 +1276,17 @@ void Verifier::visitInstruction(Instruction &I) { && isa(I.getType())), "Instruction returns a non-scalar type!", &I); + // Check that the instruction doesn't produce metadata or metadata*. Calls + // all already checked against the callee type. + Assert1(I.getType() != Type::MetadataTy || + isa(I) || isa(I), + "Invalid use of metadata!", &I); + + if (const PointerType *PTy = dyn_cast(I.getType())) + Assert1(PTy->getElementType() != Type::MetadataTy, + "Instructions may not produce pointer to metadata.", &I); + + // Check that all uses of the instruction, if they are instructions // themselves, actually have parent basic blocks. If the use is not an // instruction, it is an error! @@ -1195,7 +1296,7 @@ void Verifier::visitInstruction(Instruction &I) { *UI); Instruction *Used = cast(*UI); Assert2(Used->getParent() != 0, "Instruction referencing instruction not" - " embeded in a basic block!", &I, Used); + " embedded in a basic block!", &I, Used); } for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) { @@ -1206,6 +1307,11 @@ void Verifier::visitInstruction(Instruction &I) { if (!I.getOperand(i)->getType()->isFirstClassType()) { Assert1(0, "Instruction operands must be first-class values!", &I); } + + if (const PointerType *PTy = + dyn_cast(I.getOperand(i)->getType())) + Assert1(PTy->getElementType() != Type::MetadataTy, + "Invalid use of metadata pointer.", &I); if (Function *F = dyn_cast(I.getOperand(i))) { // Check to make sure that the "address of" an intrinsic function is never @@ -1227,67 +1333,67 @@ void Verifier::visitInstruction(Instruction &I) { BasicBlock *OpBlock = Op->getParent(); // Check that a definition dominates all of its uses. - if (!isa(I)) { + if (InvokeInst *II = dyn_cast(Op)) { // Invoke results are only usable in the normal destination, not in the // exceptional destination. - if (InvokeInst *II = dyn_cast(Op)) { - OpBlock = II->getNormalDest(); - - Assert2(OpBlock != II->getUnwindDest(), - "No uses of invoke possible due to dominance structure!", - Op, II); - + BasicBlock *NormalDest = II->getNormalDest(); + + Assert2(NormalDest != II->getUnwindDest(), + "No uses of invoke possible due to dominance structure!", + Op, &I); + + // PHI nodes differ from other nodes because they actually "use" the + // value in the predecessor basic blocks they correspond to. + BasicBlock *UseBlock = BB; + if (isa(I)) + UseBlock = cast(I.getOperand(i+1)); + + if (isa(I) && UseBlock == OpBlock) { + // Special case of a phi node in the normal destination or the unwind + // destination. + Assert2(BB == NormalDest || !DT->isReachableFromEntry(UseBlock), + "Invoke result not available in the unwind destination!", + Op, &I); + } else { + Assert2(DT->dominates(NormalDest, UseBlock) || + !DT->isReachableFromEntry(UseBlock), + "Invoke result does not dominate all uses!", Op, &I); + // If the normal successor of an invoke instruction has multiple - // predecessors, then the normal edge from the invoke is critical, so - // the invoke value can only be live if the destination block - // dominates all of it's predecessors (other than the invoke) or if - // the invoke value is only used by a phi in the successor. - if (!OpBlock->getSinglePredecessor() && - DT->dominates(&BB->getParent()->getEntryBlock(), BB)) { - // The first case we allow is if the use is a PHI operand in the - // normal block, and if that PHI operand corresponds to the invoke's - // block. - bool Bad = true; - if (PHINode *PN = dyn_cast(&I)) - if (PN->getParent() == OpBlock && - PN->getIncomingBlock(i/2) == Op->getParent()) - Bad = false; - + // predecessors, then the normal edge from the invoke is critical, + // so the invoke value can only be live if the destination block + // dominates all of it's predecessors (other than the invoke). + if (!NormalDest->getSinglePredecessor() && + DT->isReachableFromEntry(UseBlock)) // If it is used by something non-phi, then the other case is that - // 'OpBlock' dominates all of its predecessors other than the + // 'NormalDest' dominates all of its predecessors other than the // invoke. In this case, the invoke value can still be used. - if (Bad) { - Bad = false; - for (pred_iterator PI = pred_begin(OpBlock), - E = pred_end(OpBlock); PI != E; ++PI) { - if (*PI != II->getParent() && !DT->dominates(OpBlock, *PI)) { - Bad = true; - break; - } + for (pred_iterator PI = pred_begin(NormalDest), + E = pred_end(NormalDest); PI != E; ++PI) + if (*PI != II->getParent() && !DT->dominates(NormalDest, *PI) && + DT->isReachableFromEntry(*PI)) { + CheckFailed("Invoke result does not dominate all uses!", Op,&I); + return; } - } - Assert2(!Bad, - "Invoke value defined on critical edge but not dead!", &I, - Op); - } - } else if (OpBlock == BB) { + } + } else if (isa(I)) { + // PHI nodes are more difficult than other nodes because they actually + // "use" the value in the predecessor basic blocks they correspond to. + BasicBlock *PredBB = cast(I.getOperand(i+1)); + Assert2(DT->dominates(OpBlock, PredBB) || + !DT->isReachableFromEntry(PredBB), + "Instruction does not dominate all uses!", Op, &I); + } else { + if (OpBlock == BB) { // If they are in the same basic block, make sure that the definition // comes before the use. - Assert2(InstsInThisBlock.count(Op) || - !DT->dominates(&BB->getParent()->getEntryBlock(), BB), + Assert2(InstsInThisBlock.count(Op) || !DT->isReachableFromEntry(BB), "Instruction does not dominate all uses!", Op, &I); } // Definition must dominate use unless use is unreachable! Assert2(InstsInThisBlock.count(Op) || DT->dominates(Op, &I) || - !DT->dominates(&BB->getParent()->getEntryBlock(), BB), - "Instruction does not dominate all uses!", Op, &I); - } else { - // PHI nodes are more difficult than other nodes because they actually - // "use" the value in the predecessor basic blocks they correspond to. - BasicBlock *PredBB = cast(I.getOperand(i+1)); - Assert2(DT->dominates(OpBlock, PredBB) || - !DT->dominates(&BB->getParent()->getEntryBlock(), PredBB), + !DT->isReachableFromEntry(BB), "Instruction does not dominate all uses!", Op, &I); } } else if (isa(I.getOperand(i))) { @@ -1298,6 +1404,11 @@ void Verifier::visitInstruction(Instruction &I) { InstsInThisBlock.insert(&I); } +// Flags used by TableGen to mark intrinsic parameters with the +// LLVMExtendedElementVectorType and LLVMTruncatedElementVectorType classes. +static const unsigned ExtendedElementVectorType = 0x40000000; +static const unsigned TruncatedElementVectorType = 0x20000000; + /// visitIntrinsicFunction - Allow intrinsics to be verified in different ways. /// void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { @@ -1312,12 +1423,14 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { switch (ID) { default: break; - case Intrinsic::memcpy_i32: - case Intrinsic::memcpy_i64: - case Intrinsic::memmove_i32: - case Intrinsic::memmove_i64: - case Intrinsic::memset_i32: - case Intrinsic::memset_i64: + case Intrinsic::dbg_declare: // llvm.dbg.declare + if (Constant *C = dyn_cast(CI.getOperand(1))) + Assert1(C && !isa(C), + "invalid llvm.dbg.declare intrinsic call", &CI); + break; + case Intrinsic::memcpy: + case Intrinsic::memmove: + case Intrinsic::memset: Assert1(isa(CI.getOperand(4)), "alignment argument of memory intrinsics must be a constant int", &CI); @@ -1326,8 +1439,10 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { case Intrinsic::gcwrite: case Intrinsic::gcread: if (ID == Intrinsic::gcroot) { - Assert1(isa(CI.getOperand(1)->stripPointerCasts()), - "llvm.gcroot parameter #1 must be an alloca.", &CI); + AllocaInst *AI = + dyn_cast(CI.getOperand(1)->stripPointerCasts()); + Assert1(AI && isa(AI->getType()->getElementType()), + "llvm.gcroot parameter #1 must be a pointer alloca.", &CI); Assert1(isa(CI.getOperand(2)), "llvm.gcroot parameter #2 must be a constant.", &CI); } @@ -1340,17 +1455,188 @@ void Verifier::visitIntrinsicFunctionCall(Intrinsic::ID ID, CallInst &CI) { "llvm.init_trampoline parameter #2 must resolve to a function.", &CI); break; + case Intrinsic::prefetch: + Assert1(isa(CI.getOperand(2)) && + isa(CI.getOperand(3)) && + cast(CI.getOperand(2))->getZExtValue() < 2 && + cast(CI.getOperand(3))->getZExtValue() < 4, + "invalid arguments to llvm.prefetch", + &CI); + break; + case Intrinsic::stackprotector: + Assert1(isa(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(Ty); + if (VTy) { + EltTy = VTy->getElementType(); + NumElts = VTy->getNumElements(); + } + + const Type *RetTy = FTy->getReturnType(); + const StructType *ST = dyn_cast(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(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(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(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(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(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; + } + + return true; +} + /// VerifyIntrinsicPrototype - TableGen emits calls to this function into /// Intrinsics.gen. This implements a little state machine that verifies the /// prototype of intrinsics. -void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, - Function *F, - unsigned Count, ...) { +void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, Function *F, + unsigned RetNum, + unsigned ParamNum, ...) { va_list VA; - va_start(VA, Count); + va_start(VA, ParamNum); const FunctionType *FTy = F->getFunctionType(); // For overloaded intrinsics, the Suffix of the function name must match the @@ -1358,13 +1644,31 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, // suffix, to be checked at the end. std::string Suffix; - if (FTy->getNumParams() + FTy->isVarArg() != Count - 1) { + if (FTy->getNumParams() + FTy->isVarArg() != ParamNum) { CheckFailed("Intrinsic prototype has incorrect number of arguments!", F); return; } - // Note that "arg#0" is the return type. - for (unsigned ArgNo = 0; ArgNo < Count; ++ArgNo) { + const Type *Ty = FTy->getReturnType(); + const StructType *ST = dyn_cast(Ty); + + // Verify the return types. + if (ST && ST->getNumElements() != RetNum) { + CheckFailed("Intrinsic prototype has incorrect number of return types!", F); + return; + } + + for (unsigned ArgNo = 0; ArgNo < RetNum; ++ArgNo) { + int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative. + + if (ST) Ty = ST->getElementType(ArgNo); + + if (!PerformTypeCheck(ID, F, Ty, VT, ArgNo, Suffix)) + break; + } + + // Verify the parameter types. + for (unsigned ArgNo = 0; ArgNo < ParamNum; ++ArgNo) { int VT = va_arg(VA, int); // An MVT::SimpleValueType when non-negative. if (VT == MVT::isVoid && ArgNo > 0) { @@ -1373,123 +1677,9 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, break; } - const Type *Ty; - if (ArgNo == 0) - Ty = FTy->getReturnType(); - else - Ty = FTy->getParamType(ArgNo-1); - - unsigned NumElts = 0; - const Type *EltTy = Ty; - if (const VectorType *VTy = dyn_cast(Ty)) { - EltTy = VTy->getElementType(); - NumElts = VTy->getNumElements(); - } - - if (VT < 0) { - int Match = ~VT; - if (Match == 0) { - if (Ty != FTy->getReturnType()) { - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not " - "match return type.", F); - break; - } - } else { - if (Ty != FTy->getParamType(Match-1)) { - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " does not " - "match parameter %" + utostr(Match-1) + ".", F); - break; - } - } - } else if (VT == MVT::iAny) { - if (!EltTy->isInteger()) { - if (ArgNo == 0) - CheckFailed("Intrinsic result type is not " - "an integer type.", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not " - "an integer type.", F); - break; - } - unsigned GotBits = cast(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); - break; - } - } else if (VT == MVT::fAny) { - if (!EltTy->isFloatingPoint()) { - if (ArgNo == 0) - CheckFailed("Intrinsic result type is not " - "a floating-point type.", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not " - "a floating-point type.", F); - break; - } - Suffix += "."; - if (EltTy != Ty) - Suffix += "v" + utostr(NumElts); - Suffix += MVT::getMVT(EltTy).getMVTString(); - } else if (VT == MVT::iPTR) { - if (!isa(Ty)) { - if (ArgNo == 0) - CheckFailed("Intrinsic result type is not a " - "pointer and a pointer is required.", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a " - "pointer and a pointer is required.", F); - } - } 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(Ty)) { - Suffix += ".p" + utostr(PTyp->getAddressSpace()) + - MVT::getMVT(PTyp->getElementType()).getMVTString(); - } else { - if (ArgNo == 0) - CheckFailed("Intrinsic result type is not a " - "pointer and a pointer is required.", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is not a " - "pointer and a pointer is required.", F); - break; - } - } 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); - break; - } - if (VVT.getVectorNumElements() != NumElts) { - CheckFailed("Intrinsic prototype has incorrect number of " - "vector elements!",F); - break; - } - } else if (MVT((MVT::SimpleValueType)VT).getTypeForMVT() != EltTy) { - if (ArgNo == 0) - CheckFailed("Intrinsic prototype has incorrect result type!", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is wrong!",F); + if (!PerformTypeCheck(ID, F, FTy->getParamType(ArgNo), VT, ArgNo + RetNum, + Suffix)) break; - } else if (EltTy != Ty) { - if (ArgNo == 0) - CheckFailed("Intrinsic result type is vector " - "and a scalar is required.", F); - else - CheckFailed("Intrinsic parameter #" + utostr(ArgNo-1) + " is vector " - "and a scalar is required.", F); - } } va_end(VA); @@ -1512,7 +1702,7 @@ void Verifier::VerifyIntrinsicPrototype(Intrinsic::ID ID, } // Check parameter attributes. - Assert1(F->getParamAttrs() == Intrinsic::getParamAttrs(ID), + Assert1(F->getAttributes() == Intrinsic::getAttributes(ID), "Intrinsic has wrong parameter attributes!", F); }