Add verification for align, dereferenceable, dereferenceable_or_null load metadata

[apilipenko]

Summary

Verify that these appear on loads of pointer types only.

[apilipenko]

Verify required constraints, add tests.

[reames]

LGTM w/minor comments addressed.

lib/IR/Verifier.cpp

3080

I might combine these last two checks into a single one, but minor.

3230

This message could be clearer. "Alignment is larger that implementation defined limit" maybe?

lib/IR/Verifier.cpp

 ///
 void Verifier::visitInstruction(Instruction &I) {
   BasicBlock *BB = I.getParent();
   Assert(BB, "Instruction not embedded in basic block!", &I);
 
   if (!isa<PHINode>(I)) {   // Check that non-phi nodes are not self referential
     for (User *U : I.users()) {
       Assert(U != (User *)&I || !DT.isReachableFromEntry(BB),
              "Only PHI nodes may reference their own value!", &I);
     }
   }
 
   // Check that void typed values don't have names
   Assert(!I.getType()->isVoidTy() || !I.hasName(),
          "Instruction has a name, but provides a void value!", &I);
 
   // Check that the return value of the instruction is either void or a legal
void Verifier::visitInstruction(Instruction &I) {
   }
 
   if (MDNode *Range = I.getMetadata(LLVMContext::MD_range)) {
     Assert(isa<LoadInst>(I) || isa<CallInst>(I) || isa<InvokeInst>(I),
            "Ranges are only for loads, calls and invokes!", &I);
     visitRangeMetadata(I, Range, I.getType());
   }
 
-  if (I.getMetadata(LLVMContext::MD_nonnull)) {
-    Assert(I.getType()->isPointerTy(), "nonnull applies only to pointer types",
+  if (I.getMetadata(LLVMContext::MD_nonnull) ||
+      I.getMetadata(LLVMContext::MD_dereferenceable ||
+      I.getMetadata(LLVMContext::MD_dereferenceable_or_null) ||
+      I.getMetadata(LLVMContext::MD_align) {
+    Assert(I.getType()->isPointerTy(), "nonnull, align, derefernceable, "
+           "derefernceable_or_null metadata apply only to pointer types",
            &I);
     Assert(isa<LoadInst>(I),
-           "nonnull applies only to load instructions, use attributes"
-           " for calls or invokes",
+           "nonnull, align, derefernceable, derefernceable_or_null apply "
+            "only to load instructions, use attributes for calls or invokes",
            &I);
   }
 
   if (MDNode *N = I.getDebugLoc().getAsMDNode()) {
     Assert(isa<DILocation>(N), "invalid !dbg metadata attachment", &I, N);
     visitMDNode(*N);
   }
 
   InstsInThisBlock.insert(&I);
 }
 
 /// VerifyIntrinsicType - Verify that the specified type (which comes from an
 /// intrinsic argument or return value) matches the type constraints specified
 /// by the .td file (e.g. an "any integer" argument really is an integer).
 ///
 /// This return true on error but does not print a message.
 bool Verifier::VerifyIntrinsicType(Type *Ty,
                                    ArrayRef<Intrinsic::IITDescriptor> &Infos,
                                    SmallVectorImpl<Type*> &ArgTys) {
   using namespace Intrinsic;
 
   // If we ran out of descriptors, there are too many arguments.
   if (Infos.empty()) return true;
   IITDescriptor D = Infos.front();
   Infos = Infos.slice(1);
 
   switch (D.Kind) {
   case IITDescriptor::Void: return !Ty->isVoidTy();
   case IITDescriptor::VarArg: return true;
   case IITDescriptor::MMX:  return !Ty->isX86_MMXTy();
   case IITDescriptor::Token: return !Ty->isTokenTy();