[NFC] LoadInst: add two helper methods: getLoadedSize and getActualAlignment.

[eddyb]

Summary

Depends on http://reviews.llvm.org/D16425, only commit after that.

[mjacob]

I think we should reverse the dependency and commit this before D16425.

include/llvm/IR/Instructions.h

296

I'm not sure I like this name. Unfortunately, I don't have a better idea. ;) Let me think about this over night, I won't accept this revision before tomorrow anyway.

298

I think it's more correct to say that this is the amount of bytes this instruction loads from memory. The loaded value doesn't really have a size.

include/llvm/IR/Instructions.h

public:
   const Value *getPointerOperand() const { return getOperand(0); }
   static unsigned getPointerOperandIndex() { return 0U; }
 
   /// \brief Returns the address space of the pointer operand.
   unsigned getPointerAddressSpace() const {
     return getPointerOperand()->getType()->getPointerAddressSpace();
   }
 
+  /// \brief Returns the explicit aligment, if present, or the ABI one.
+  unsigned getActualAlignment() const;
+
+  /// \brief Returns the size in bytes of the loaded value.
+  uint64_t getLoadedSize() const;
+
   // Methods for support type inquiry through isa, cast, and dyn_cast:
   static inline bool classof(const Instruction *I) {
     return I->getOpcode() == Instruction::Load;
   }
   static inline bool classof(const Value *V) {
     return isa<Instruction>(V) && classof(cast<Instruction>(V));
   }
 

lib/Analysis/MemDerefPrinter.cpp

FunctionPass *llvm::createMemDerefPrinter() {
   return new MemDerefPrinter();
 }
 
 bool MemDerefPrinter::runOnFunction(Function &F) {
   const DataLayout &DL = F.getParent()->getDataLayout();
   for (auto &I: instructions(F)) {
     if (LoadInst *LI = dyn_cast<LoadInst>(&I)) {
       Value *PO = LI->getPointerOperand();
-      uint64_t Size = DL.getTypeStoreSize(LI->getType());
-      unsigned Align = LI->getAlignment();
-      if (Align == 0)
-        Align = DL.getABITypeAlignment(LI->getType());
+      uint64_t Size = LI->getLoadedSize();
+      unsigned Align = LI->getActualAlignment();
       if (isDereferenceablePointer(PO, Size, DL))
         Deref.push_back(PO);
       if (isDereferenceableAndAlignedPointer(PO, Size, Align, DL))
         DerefAndAligned.insert(PO);
     }
   }
   return false;
 }

lib/Analysis/ValueTracking.cpp

if (!LI->isUnordered() ||
         // Speculative load may create a race that did not exist in the source.
         LI->getParent()->getParent()->hasFnAttribute(
             Attribute::SanitizeThread) ||
         // Speculative load may load data from dirty regions.
         LI->getParent()->getParent()->hasFnAttribute(
             Attribute::SanitizeAddress))
       return false;
     const DataLayout &DL = LI->getModule()->getDataLayout();
-    uint64_t Size = DL.getTypeStoreSize(LI->getType());
-    unsigned Align = LI->getAlignment();
-    if (Align == 0)
-      Align = DL.getABITypeAlignment(LI->getType());
     return isDereferenceableAndAlignedPointer(
-        LI->getPointerOperand(), Size, Align, DL, CtxI, DT, TLI);
+        LI->getPointerOperand(), LI->getLoadedSize(),
+        LI->getActualAlignment(), DL, CtxI, DT, TLI);
   }
   case Instruction::Call: {
     if (const IntrinsicInst *II = dyn_cast<IntrinsicInst>(Inst)) {
       switch (II->getIntrinsicID()) {
       // These synthetic intrinsics have no side-effects and just mark
       // information about their operands.
       // FIXME: There are other no-op synthetic instructions that potentially
       // should be considered at least *safe* to speculate...

lib/IR/Instructions.cpp

void LoadInst::setAlignment(unsigned Align) {
   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
   assert(Align <= MaximumAlignment &&
          "Alignment is greater than MaximumAlignment!");
   setInstructionSubclassData((getSubclassDataFromInstruction() & ~(31 << 1)) |
                              ((Log2_32(Align)+1)<<1));
   assert(getAlignment() == Align && "Alignment representation error!");
 }
 
+unsigned LoadInst::getActualAlignment() const {
+  unsigned Align = getAlignment();
+  if (Align == 0) {
+    const DataLayout &DL = getModule()->getDataLayout();
+    return DL.getABITypeAlignment(getType());
+  }
+  return Align;
+}
+
+uint64_t LoadInst::getLoadedSize() const {
+  const DataLayout &DL = getModule()->getDataLayout();
+  return DL.getTypeStoreSize(getType());
+}
+
 //===----------------------------------------------------------------------===//
 //                           StoreInst Implementation
 //===----------------------------------------------------------------------===//
 
 void StoreInst::AssertOK() {
   assert(getOperand(0) && getOperand(1) && "Both operands must be non-null!");
   assert(getOperand(1)->getType()->isPointerTy() &&
          "Ptr must have pointer type!");