introduce a new RoundUpAlignment helper function, use it to

remove some more 64-bit divs and rems from the StructLayout 
ctor.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@60692 91177308-0d34-0410-b5e6-96231b3b80d8

include/llvm/Target/TargetData.h

@@ -178,12 +178,8 @@ public:
   /// that alloca reserves for this type.  For example, returns 12 or 16 for
   /// x86_fp80, depending on alignment.
   uint64_t getABITypeSize(const Type* Ty) const {
-    // The alignment of a type is always a power of two.
-    unsigned char AlignMinusOne = getABITypeAlignment(Ty)-1;
-
     // Round up to the next alignment boundary.
-    uint64_t RoundUp = getTypeStoreSize(Ty) + AlignMinusOne;
+    return RoundUpAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
-    return RoundUp &= ~uint64_t(AlignMinusOne);
   }
 
   /// getABITypeSizeInBits - Return the offset in bits between successive
@@ -244,6 +240,16 @@ public:
   /// requested alignment (if the global has one).
   unsigned getPreferredAlignmentLog(const GlobalVariable *GV) const;
 
+  /// RoundUpAlignment - Round the specified value up to the next alignment
+  /// boundary specified by Alignment.  For example, 7 rounded up to an
+  /// alignment boundary of 4 is 8.  8 rounded up to the alignment boundary of 4
+  /// is 8 because it is already aligned.
+  template <typename UIntTy>
+  static UIntTy RoundUpAlignment(UIntTy Val, unsigned Alignment) {
+    assert((Alignment & (Alignment-1)) == 0 && "Alignment must be power of 2!");
+    return (Val + (Alignment-1)) & ~UIntTy(Alignment-1);
+  }
+  
   static char ID; // Pass identification, replacement for typeid
 };
 

lib/Target/TargetData.cpp

@@ -45,15 +45,16 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
   StructSize = 0;
   NumElements = ST->getNumElements();
 
-  // Loop over each of the elements, placing them in memory...
+  // Loop over each of the elements, placing them in memory.
   for (unsigned i = 0, e = NumElements; i != e; ++i) {
     const Type *Ty = ST->getElementType(i);
     unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
 
-    // Add padding if necessary to align the data element properly...
+    // Add padding if necessary to align the data element properly.
-    StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
+    if (StructSize & TyAlign-1)
+      StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
 
-    // Keep track of maximum alignment constraint
+    // Keep track of maximum alignment constraint.
     StructAlignment = std::max(TyAlign, StructAlignment);
 
     MemberOffsets[i] = StructSize;
@@ -65,8 +66,8 @@ StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
 
   // Add padding to the end of the struct so that it could be put in an array
   // and all array elements would be aligned correctly.
-  if (StructSize % StructAlignment != 0)
+  if (StructSize & (StructAlignment-1) != 0)
-    StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
+    StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
 }
 
 
@@ -346,18 +347,18 @@ typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
 static ManagedStatic<LayoutInfoTy> LayoutInfo;
 
 TargetData::~TargetData() {
-  if (LayoutInfo.isConstructed()) {
+  if (!LayoutInfo.isConstructed())
-    // Remove any layouts for this TD.
+    return;
-    LayoutInfoTy &TheMap = *LayoutInfo;
+  
-    for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
+  // Remove any layouts for this TD.
-         I != E; ) {
+  LayoutInfoTy &TheMap = *LayoutInfo;
-      if (I->first.first == this) {
+  for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
-        I->second->~StructLayout();
+    if (I->first.first == this) {
-        free(I->second);
+      I->second->~StructLayout();
-        TheMap.erase(I++);
+      free(I->second);
-      } else {
+      TheMap.erase(I++);
-        ++I;
+    } else {
-      }
+      ++I;
     }
   }
 }
@@ -390,11 +391,11 @@ void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
   if (!LayoutInfo.isConstructed()) return;  // No cache.
   
   LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
-  if (I != LayoutInfo->end()) {
+  if (I == LayoutInfo->end()) return;
-    I->second->~StructLayout();
+  
-    free(I->second);
+  I->second->~StructLayout();
-    LayoutInfo->erase(I);
+  free(I->second);
-  }
+  LayoutInfo->erase(I);
 }
 
 
@@ -426,11 +427,9 @@ uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
     const ArrayType *ATy = cast<ArrayType>(Ty);
     return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
   }
-  case Type::StructTyID: {
+  case Type::StructTyID:
     // Get the layout annotation... which is lazily created on demand.
-    const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
+    return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
-    return Layout->getSizeInBits();
-  }
   case Type::IntegerTyID:
     return cast<IntegerType>(Ty)->getBitWidth();
   case Type::VoidTyID:
@@ -446,10 +445,8 @@ uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
   // only 80 bits contain information.
   case Type::X86_FP80TyID:
     return 80;
-  case Type::VectorTyID: {
+  case Type::VectorTyID:
-    const VectorType *PTy = cast<VectorType>(Ty);
+    return cast<VectorType>(Ty)->getBitWidth();
-    return PTy->getBitWidth();
-  }
   default:
     assert(0 && "TargetData::getTypeSizeInBits(): Unsupported type");
     break;
@@ -470,7 +467,7 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 
   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
   switch (Ty->getTypeID()) {
-  /* Early escape for the non-numeric types */
+  // Early escape for the non-numeric types.
   case Type::LabelTyID:
   case Type::PointerTyID:
     return (abi_or_pref