reference, declarationdefinition
definition → references, declarations, derived classes, virtual overrides
reference to multiple definitions → definitions
unreferenced

References

lib/IR/Verifier.cpp
 4061   BasicBlock *BB = I.getParent();
 4062   Assert(BB, "Instruction not embedded in basic block!", &I);
 4064   if (!isa<PHINode>(I)) {   // Check that non-phi nodes are not self referential
 4065     for (User *U : I.users()) {
 4066       Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
 4067              "Only PHI nodes may reference their own value!", &I);
 4072   Assert(!I.getType()->isVoidTy() || !I.hasName(),
 4072   Assert(!I.getType()->isVoidTy() || !I.hasName(),
 4073          "Instruction has a name, but provides a void value!", &I);
 4077   Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
 4077   Assert(I.getType()->isVoidTy() || I.getType()->isFirstClassType(),
 4078          "Instruction returns a non-scalar type!", &I);
 4082   Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
 4082   Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
 4082   Assert(!I.getType()->isMetadataTy() || isa<CallInst>(I) || isa<InvokeInst>(I),
 4083          "Invalid use of metadata!", &I);
 4088   for (Use &U : I.uses()) {
 4093              &I, Used);
 4102   const CallBase *CBI = dyn_cast<CallBase>(&I);
 4104   for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
 4105     Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
 4105     Assert(I.getOperand(i) != nullptr, "Instruction has null operand!", &I);
 4109     if (!I.getOperand(i)->getType()->isFirstClassType()) {
 4110       Assert(false, "Instruction operands must be first-class values!", &I);
 4113     if (Function *F = dyn_cast<Function>(I.getOperand(i))) {
 4117                  (CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i)),
 4118              "Cannot take the address of an intrinsic!", &I);
 4120           !F->isIntrinsic() || isa<CallInst>(I) ||
 4130           &I);
 4132              &I, &M, F, F->getParent());
 4133     } else if (BasicBlock *OpBB = dyn_cast<BasicBlock>(I.getOperand(i))) {
 4135              "Referring to a basic block in another function!", &I);
 4136     } else if (Argument *OpArg = dyn_cast<Argument>(I.getOperand(i))) {
 4138              "Referring to an argument in another function!", &I);
 4139     } else if (GlobalValue *GV = dyn_cast<GlobalValue>(I.getOperand(i))) {
 4140       Assert(GV->getParent() == &M, "Referencing global in another module!", &I,
 4142     } else if (isa<Instruction>(I.getOperand(i))) {
 4143       verifyDominatesUse(I, i);
 4144     } else if (isa<InlineAsm>(I.getOperand(i))) {
 4145       Assert(CBI && &CBI->getCalledOperandUse() == &I.getOperandUse(i),
 4146              "Cannot take the address of an inline asm!", &I);
 4147     } else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(I.getOperand(i))) {
 4159   if (MDNode *MD = I.getMetadata(LLVMContext::MD_fpmath)) {
 4160     Assert(I.getType()->isFPOrFPVectorTy(),
 4161            "fpmath requires a floating point result!", &I);
 4162     Assert(MD->getNumOperands() == 1, "fpmath takes one operand!", &I);
 4167              "fpmath accuracy must have float type", &I);
 4169              "fpmath accuracy not a positive number!", &I);
 4171       Assert(false, "invalid fpmath accuracy!", &I);
 4175   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
 4176     Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
 4176     Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
 4176     Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
 4177            "Ranges are only for loads, calls and invokes!", &I);
 4178     visitRangeMetadata(I, Range, I.getType());
 4178     visitRangeMetadata(I, Range, I.getType());
 4181   if (I.getMetadata(LLVMContext::MD_nonnull)) {
 4182     Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
 4183            &I);
 4184     Assert(isa<LoadInst>(I),
 4187            &I);
 4190   if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable))
 4191     visitDereferenceableMetadata(I, MD);
 4193   if (MDNode *MD = I.getMetadata(LLVMContext::MD_dereferenceable_or_null))
 4194     visitDereferenceableMetadata(I, MD);
 4196   if (MDNode *TBAA = I.getMetadata(LLVMContext::MD_tbaa))
 4197     TBAAVerifyHelper.visitTBAAMetadata(I, TBAA);
 4199   if (MDNode *AlignMD = I.getMetadata(LLVMContext::MD_align)) {
 4200     Assert(I.getType()->isPointerTy(), "align applies only to pointer types",
 4201            &I);
 4202     Assert(isa<LoadInst>(I), "align applies only to load instructions, "
 4203            "use attributes for calls or invokes", &I);
 4204     Assert(AlignMD->getNumOperands() == 1, "align takes one operand!", &I);
 4207            "align metadata value must be an i64!", &I);
 4210            "align metadata value must be a power of 2!", &I);
 4212            "alignment is larger that implementation defined limit", &I);
 4215   if (MDNode *MD = I.getMetadata(LLVMContext::MD_prof))
 4216     visitProfMetadata(I, MD);
 4218   if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
 4219     AssertDI(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
 4223   if (auto *DII = dyn_cast<DbgVariableIntrinsic>(&I)) {
 4228   InstsInThisBlock.insert(&I);