Be bug compatible with gcc by returning MMX values in RAX.

[oota-llvm.git] / lib / Target / TargetData.cpp

diff --git a/lib/Target/TargetData.cpp b/lib/Target/TargetData.cpp
index f83adefbee3426e2124a3c093aef21a6d274db9e..63b3eaafe1be92361f24e7e388048b3876aef069 100644 (file)
--- a/lib/Target/TargetData.cpp
+++ b/lib/Target/TargetData.cpp
@@ -45,19 +45,20 @@ 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...
-    StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
+    // Add padding if necessary to align the data element properly.
+    if ((StructSize & (TyAlign-1)) != 0)
+      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;
-    StructSize += TD.getABITypeSize(Ty); // Consume space for this data item
+    StructSize += TD.getTypePaddedSize(Ty); // Consume space for this data item
   }
 
   // Empty structures have alignment of 1 byte.
@@ -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)
-    StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
+  if ((StructSize & (StructAlignment-1)) != 0)
+    StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
 }
 
 
@@ -232,7 +233,7 @@ void TargetData::init(const std::string &TargetDescription) {
 }
 
 TargetData::TargetData(const Module *M) 
-  : ImmutablePass((intptr_t)&ID) {
+  : ImmutablePass(&ID) {
   init(M->getDataLayout());
 }
 
@@ -301,14 +302,14 @@ unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
       BestMatchIdx = LargestInt;
     } else {
       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
-      
+
       // If we didn't find a vector size that is smaller or equal to this type,
       // then we will end up scalarizing this to its element type.  Just return
       // the alignment of the element.
       return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
-    }    
+    }
   }
-    
+
   // Since we got a "best match" index, just return it.
   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
                  : Alignments[BestMatchIdx].PrefAlign;
@@ -346,18 +347,18 @@ typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
 static ManagedStatic<LayoutInfoTy> LayoutInfo;
 
 TargetData::~TargetData() {
-  if (LayoutInfo.isConstructed()) {
-    // Remove any layouts for this TD.
-    LayoutInfoTy &TheMap = *LayoutInfo;
-    for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
-         I != E; ) {
-      if (I->first.first == this) {
-        I->second->~StructLayout();
-        free(I->second);
-        TheMap.erase(I++);
-      } else {
-        ++I;
-      }
+  if (!LayoutInfo.isConstructed())
+    return;
+  
+  // Remove any layouts for this TD.
+  LayoutInfoTy &TheMap = *LayoutInfo;
+  for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
+    if (I->first.first == this) {
+      I->second->~StructLayout();
+      free(I->second);
+      TheMap.erase(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()) {
-    I->second->~StructLayout();
-    free(I->second);
-    LayoutInfo->erase(I);
-  }
+  if (I == LayoutInfo->end()) return;
+  
+  I->second->~StructLayout();
+  free(I->second);
+  LayoutInfo->erase(I);
 }
 
 
@@ -424,13 +425,11 @@ uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
     return getPointerSizeInBits();
   case Type::ArrayTyID: {
     const ArrayType *ATy = cast<ArrayType>(Ty);
-    return getABITypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
+    return getTypePaddedSizeInBits(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 Layout->getSizeInBits();
-  }
+    return getStructLayout(cast<StructType>(Ty))->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: {
-    const VectorType *PTy = cast<VectorType>(Ty);
-    return PTy->getBitWidth();
-  }
+  case Type::VectorTyID:
+    return cast<VectorType>(Ty)->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
@@ -478,12 +475,12 @@ unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
             : getPointerPrefAlignment());
   case Type::ArrayTyID:
     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
-    
+
   case Type::StructTyID: {
     // Packed structure types always have an ABI alignment of one.
     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
       return 1;
-    
+
     // Get the layout annotation... which is lazily created on demand.
     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
@@ -571,7 +568,7 @@ uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 
       // Get the array index and the size of each array element.
       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
-      Result += arrayIdx * (int64_t)getABITypeSize(Ty);
+      Result += arrayIdx * (int64_t)getTypePaddedSize(Ty);
     }
   }