lib/Target/TargetData.cpp

   1 //===-- TargetData.cpp - Data size & alignment routines --------------------==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This file defines target properties related to datatype size/offset/alignment
  11 // information.
  12 //
  13 // This structure should be created once, filled in if the defaults are not
  14 // correct and then passed around by const&.  None of the members functions
  15 // require modification to the object.
  16 //
  17 //===----------------------------------------------------------------------===//
  18
  19 #include "llvm/Target/TargetData.h"
  20 #include "llvm/Module.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Constants.h"
  23 #include "llvm/Support/GetElementPtrTypeIterator.h"
  24 #include "llvm/Support/MathExtras.h"
  25 #include "llvm/Support/ManagedStatic.h"
  26 #include "llvm/Support/ErrorHandling.h"
  27 #include "llvm/Support/raw_ostream.h"
  28 #include "llvm/System/Mutex.h"
  29 #include "llvm/ADT/DenseMap.h"
  30 #include <algorithm>
  31 #include <cstdlib>
  32 using namespace llvm;
  33
  34 // Handle the Pass registration stuff necessary to use TargetData's.
  35
  36 // Register the default SparcV9 implementation...
  37 static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
  38                                   true);
  39 char TargetData::ID = 0;
  40
  41 //===----------------------------------------------------------------------===//
  42 // Support for StructLayout
  43 //===----------------------------------------------------------------------===//
  44
  45 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
  46   StructAlignment = 0;
  47   StructSize = 0;
  48   NumElements = ST->getNumElements();
  49
  50   // Loop over each of the elements, placing them in memory.
  51   for (unsigned i = 0, e = NumElements; i != e; ++i) {
  52     const Type *Ty = ST->getElementType(i);
  53     unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
  54
  55     // Add padding if necessary to align the data element properly.
  56     if ((StructSize & (TyAlign-1)) != 0)
  57       StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
  58
  59     // Keep track of maximum alignment constraint.
  60     StructAlignment = std::max(TyAlign, StructAlignment);
  61
  62     MemberOffsets[i] = StructSize;
  63     StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
  64   }
  65
  66   // Empty structures have alignment of 1 byte.
  67   if (StructAlignment == 0) StructAlignment = 1;
  68
  69   // Add padding to the end of the struct so that it could be put in an array
  70   // and all array elements would be aligned correctly.
  71   if ((StructSize & (StructAlignment-1)) != 0)
  72     StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
  73 }
  74
  75
  76 /// getElementContainingOffset - Given a valid offset into the structure,
  77 /// return the structure index that contains it.
  78 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
  79   const uint64_t *SI =
  80     std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
  81   assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
  82   --SI;
  83   assert(*SI <= Offset && "upper_bound didn't work");
  84   assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
  85          (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
  86          "Upper bound didn't work!");
  87
  88   // Multiple fields can have the same offset if any of them are zero sized.
  89   // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
  90   // at the i32 element, because it is the last element at that offset.  This is
  91   // the right one to return, because anything after it will have a higher
  92   // offset, implying that this element is non-empty.
  93   return SI-&MemberOffsets[0];
  94 }
  95
  96 //===----------------------------------------------------------------------===//
  97 // TargetAlignElem, TargetAlign support
  98 //===----------------------------------------------------------------------===//
  99
 100 TargetAlignElem
 101 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
 102                      unsigned char pref_align, uint32_t bit_width) {
 103   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 104   TargetAlignElem retval;
 105   retval.AlignType = align_type;
 106   retval.ABIAlign = abi_align;
 107   retval.PrefAlign = pref_align;
 108   retval.TypeBitWidth = bit_width;
 109   return retval;
 110 }
 111
 112 bool
 113 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
 114   return (AlignType == rhs.AlignType
 115           && ABIAlign == rhs.ABIAlign
 116           && PrefAlign == rhs.PrefAlign
 117           && TypeBitWidth == rhs.TypeBitWidth);
 118 }
 119
 120 std::ostream &
 121 TargetAlignElem::dump(std::ostream &os) const {
 122   return os << AlignType
 123             << TypeBitWidth
 124             << ":" << (int) (ABIAlign * 8)
 125             << ":" << (int) (PrefAlign * 8);
 126 }
 127
 128 const TargetAlignElem TargetData::InvalidAlignmentElem =
 129                 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 130
 131 //===----------------------------------------------------------------------===//
 132 //                       TargetData Class Implementation
 133 //===----------------------------------------------------------------------===//
 134
 135 /// getInt - Get an integer ignoring errors.
 136 static unsigned getInt(StringRef R) {
 137   unsigned Result = 0;
 138   R.getAsInteger(10, Result);
 139   return Result;
 140 }
 141
 142 void TargetData::init(StringRef Desc) {
 143   LayoutMap = 0;
 144   LittleEndian = false;
 145   PointerMemSize = 8;
 146   PointerABIAlign = 8;
 147   PointerPrefAlign = PointerABIAlign;
 148
 149   // Default alignments
 150   setAlignment(INTEGER_ALIGN,   1,  1, 1);   // i1
 151   setAlignment(INTEGER_ALIGN,   1,  1, 8);   // i8
 152   setAlignment(INTEGER_ALIGN,   2,  2, 16);  // i16
 153   setAlignment(INTEGER_ALIGN,   4,  4, 32);  // i32
 154   setAlignment(INTEGER_ALIGN,   4,  8, 64);  // i64
 155   setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 156   setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 157   setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32, v1i64, ...
 158   setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 159   setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct
 160
 161   while (!Desc.empty()) {
 162     std::pair<StringRef, StringRef> Split = Desc.split('-');
 163     StringRef Token = Split.first;
 164     Desc = Split.second;
 165
 166     if (Token.empty())
 167       continue;
 168
 169     Split = Token.split(':');
 170     StringRef Specifier = Split.first;
 171     Token = Split.second;
 172
 173     assert(!Specifier.empty() && "Can't be empty here");
 174
 175     switch (Specifier[0]) {
 176     case 'E':
 177       LittleEndian = false;
 178       break;
 179     case 'e':
 180       LittleEndian = true;
 181       break;
 182     case 'p':
 183       Split = Token.split(':');
 184       PointerMemSize = getInt(Split.first) / 8;
 185       Split = Split.second.split(':');
 186       PointerABIAlign = getInt(Split.first) / 8;
 187       Split = Split.second.split(':');
 188       PointerPrefAlign = getInt(Split.first) / 8;
 189       if (PointerPrefAlign == 0)
 190         PointerPrefAlign = PointerABIAlign;
 191       break;
 192     case 'i':
 193     case 'v':
 194     case 'f':
 195     case 'a':
 196     case 's': {
 197       AlignTypeEnum AlignType;
 198       switch (Specifier[0]) {
 199       default:
 200       case 'i': AlignType = INTEGER_ALIGN; break;
 201       case 'v': AlignType = VECTOR_ALIGN; break;
 202       case 'f': AlignType = FLOAT_ALIGN; break;
 203       case 'a': AlignType = AGGREGATE_ALIGN; break;
 204       case 's': AlignType = STACK_ALIGN; break;
 205       }
 206       unsigned Size = getInt(Specifier.substr(1));
 207       Split = Token.split(':');
 208       unsigned char ABIAlign = getInt(Split.first) / 8;
 209
 210       Split = Split.second.split(':');
 211       unsigned char PrefAlign = getInt(Split.first) / 8;
 212       if (PrefAlign == 0)
 213         PrefAlign = ABIAlign;
 214       setAlignment(AlignType, ABIAlign, PrefAlign, Size);
 215       break;
 216     }
 217     case 'n':  // Native integer types.
 218       Specifier = Specifier.substr(1);
 219       do {
 220         if (unsigned Width = getInt(Specifier))
 221           LegalIntWidths.push_back(Width);
 222         Split = Token.split(':');
 223         Specifier = Split.first;
 224         Token = Split.second;
 225       } while (!Specifier.empty() || !Token.empty());
 226       break;
 227
 228     default:
 229       break;
 230     }
 231   }
 232 }
 233
 234 /// Default ctor.
 235 ///
 236 /// @note This has to exist, because this is a pass, but it should never be
 237 /// used.
 238 TargetData::TargetData() : ImmutablePass(&ID) {
 239   llvm_report_error("Bad TargetData ctor used.  "
 240                     "Tool did not specify a TargetData to use?");
 241 }
 242
 243 TargetData::TargetData(const Module *M)
 244   : ImmutablePass(&ID) {
 245   init(M->getDataLayout());
 246 }
 247
 248 void
 249 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
 250                          unsigned char pref_align, uint32_t bit_width) {
 251   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 252   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 253     if (Alignments[i].AlignType == align_type &&
 254         Alignments[i].TypeBitWidth == bit_width) {
 255       // Update the abi, preferred alignments.
 256       Alignments[i].ABIAlign = abi_align;
 257       Alignments[i].PrefAlign = pref_align;
 258       return;
 259     }
 260   }
 261
 262   Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 263                                             pref_align, bit_width));
 264 }
 265
 266 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
 267 /// preferred if ABIInfo = false) the target wants for the specified datatype.
 268 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
 269                                       uint32_t BitWidth, bool ABIInfo,
 270                                       const Type *Ty) const {
 271   // Check to see if we have an exact match and remember the best match we see.
 272   int BestMatchIdx = -1;
 273   int LargestInt = -1;
 274   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 275     if (Alignments[i].AlignType == AlignType &&
 276         Alignments[i].TypeBitWidth == BitWidth)
 277       return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 278
 279     // The best match so far depends on what we're looking for.
 280     if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
 281       // If this is a specification for a smaller vector type, we will fall back
 282       // to it.  This happens because <128 x double> can be implemented in terms
 283       // of 64 <2 x double>.
 284       if (Alignments[i].TypeBitWidth < BitWidth) {
 285         // Verify that we pick the biggest of the fallbacks.
 286         if (BestMatchIdx == -1 ||
 287             Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
 288           BestMatchIdx = i;
 289       }
 290     } else if (AlignType == INTEGER_ALIGN &&
 291                Alignments[i].AlignType == INTEGER_ALIGN) {
 292       // The "best match" for integers is the smallest size that is larger than
 293       // the BitWidth requested.
 294       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 295            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 296         BestMatchIdx = i;
 297       // However, if there isn't one that's larger, then we must use the
 298       // largest one we have (see below)
 299       if (LargestInt == -1 ||
 300           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 301         LargestInt = i;
 302     }
 303   }
 304
 305   // Okay, we didn't find an exact solution.  Fall back here depending on what
 306   // is being looked for.
 307   if (BestMatchIdx == -1) {
 308     // If we didn't find an integer alignment, fall back on most conservative.
 309     if (AlignType == INTEGER_ALIGN) {
 310       BestMatchIdx = LargestInt;
 311     } else {
 312       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 313
 314       // If we didn't find a vector size that is smaller or equal to this type,
 315       // then we will end up scalarizing this to its element type.  Just return
 316       // the alignment of the element.
 317       return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
 318     }
 319   }
 320
 321   // Since we got a "best match" index, just return it.
 322   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 323                  : Alignments[BestMatchIdx].PrefAlign;
 324 }
 325
 326 typedef DenseMap<const StructType*, StructLayout*>LayoutInfoTy;
 327
 328 TargetData::~TargetData() {
 329   if (!LayoutMap)
 330     return;
 331
 332   // Remove any layouts for this TD.
 333   LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
 334   for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
 335     I->second->~StructLayout();
 336     free(I->second);
 337     TheMap.erase(I++);
 338   }
 339
 340   delete static_cast<LayoutInfoTy*>(LayoutMap);
 341 }
 342
 343 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 344   if (!LayoutMap)
 345     LayoutMap = static_cast<void*>(new LayoutInfoTy());
 346
 347   LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
 348
 349   StructLayout *&SL = TheMap[Ty];
 350   if (SL) return SL;
 351
 352   // Otherwise, create the struct layout.  Because it is variable length, we
 353   // malloc it, then use placement new.
 354   int NumElts = Ty->getNumElements();
 355   StructLayout *L =
 356     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
 357
 358   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 359   // entries to be added to TheMap, invalidating our reference.
 360   SL = L;
 361
 362   new (L) StructLayout(Ty, *this);
 363   return L;
 364 }
 365
 366 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 367 /// objects.  If a TargetData object is alive when types are being refined and
 368 /// removed, this method must be called whenever a StructType is removed to
 369 /// avoid a dangling pointer in this cache.
 370 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 371   if (!LayoutMap) return;  // No cache.
 372
 373   LayoutInfoTy* LayoutInfo = static_cast<LayoutInfoTy*>(LayoutMap);
 374   LayoutInfoTy::iterator I = LayoutInfo->find(Ty);
 375   if (I == LayoutInfo->end()) return;
 376
 377   I->second->~StructLayout();
 378   free(I->second);
 379   LayoutInfo->erase(I);
 380 }
 381
 382
 383 std::string TargetData::getStringRepresentation() const {
 384   std::string Result;
 385   raw_string_ostream OS(Result);
 386
 387   OS << (LittleEndian ? "e" : "E")
 388      << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
 389      << ':' << PointerPrefAlign*8;
 390   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 391     const TargetAlignElem &AI = Alignments[i];
 392     OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
 393        << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
 394   }
 395
 396   if (!LegalIntWidths.empty()) {
 397     OS << "-n" << (unsigned)LegalIntWidths[0];
 398
 399     for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
 400       OS << ':' << (unsigned)LegalIntWidths[i];
 401   }
 402   return OS.str();
 403 }
 404
 405
 406 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 407   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 408   switch (Ty->getTypeID()) {
 409   case Type::LabelTyID:
 410   case Type::PointerTyID:
 411     return getPointerSizeInBits();
 412   case Type::ArrayTyID: {
 413     const ArrayType *ATy = cast<ArrayType>(Ty);
 414     return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
 415   }
 416   case Type::StructTyID:
 417     // Get the layout annotation... which is lazily created on demand.
 418     return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 419   case Type::IntegerTyID:
 420     return cast<IntegerType>(Ty)->getBitWidth();
 421   case Type::VoidTyID:
 422     return 8;
 423   case Type::FloatTyID:
 424     return 32;
 425   case Type::DoubleTyID:
 426     return 64;
 427   case Type::PPC_FP128TyID:
 428   case Type::FP128TyID:
 429     return 128;
 430   // In memory objects this is always aligned to a higher boundary, but
 431   // only 80 bits contain information.
 432   case Type::X86_FP80TyID:
 433     return 80;
 434   case Type::VectorTyID:
 435     return cast<VectorType>(Ty)->getBitWidth();
 436   default:
 437     llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 438     break;
 439   }
 440   return 0;
 441 }
 442
 443 /*!
 444   \param abi_or_pref Flag that determines which alignment is returned. true
 445   returns the ABI alignment, false returns the preferred alignment.
 446   \param Ty The underlying type for which alignment is determined.
 447
 448   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 449   == false) for the requested type \a Ty.
 450  */
 451 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 452   int AlignType = -1;
 453
 454   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 455   switch (Ty->getTypeID()) {
 456   // Early escape for the non-numeric types.
 457   case Type::LabelTyID:
 458   case Type::PointerTyID:
 459     return (abi_or_pref
 460             ? getPointerABIAlignment()
 461             : getPointerPrefAlignment());
 462   case Type::ArrayTyID:
 463     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 464
 465   case Type::StructTyID: {
 466     // Packed structure types always have an ABI alignment of one.
 467     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 468       return 1;
 469
 470     // Get the layout annotation... which is lazily created on demand.
 471     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 472     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 473     return std::max(Align, (unsigned)Layout->getAlignment());
 474   }
 475   case Type::IntegerTyID:
 476   case Type::VoidTyID:
 477     AlignType = INTEGER_ALIGN;
 478     break;
 479   case Type::FloatTyID:
 480   case Type::DoubleTyID:
 481   // PPC_FP128TyID and FP128TyID have different data contents, but the
 482   // same size and alignment, so they look the same here.
 483   case Type::PPC_FP128TyID:
 484   case Type::FP128TyID:
 485   case Type::X86_FP80TyID:
 486     AlignType = FLOAT_ALIGN;
 487     break;
 488   case Type::VectorTyID:
 489     AlignType = VECTOR_ALIGN;
 490     break;
 491   default:
 492     llvm_unreachable("Bad type for getAlignment!!!");
 493     break;
 494   }
 495
 496   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 497                           abi_or_pref, Ty);
 498 }
 499
 500 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 501   return getAlignment(Ty, true);
 502 }
 503
 504 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
 505   for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 506     if (Alignments[i].AlignType == STACK_ALIGN)
 507       return Alignments[i].ABIAlign;
 508
 509   return getABITypeAlignment(Ty);
 510 }
 511
 512 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 513   return getAlignment(Ty, false);
 514 }
 515
 516 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 517   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 518   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 519   return Log2_32(Align);
 520 }
 521
 522 /// getIntPtrType - Return an unsigned integer type that is the same size or
 523 /// greater to the host pointer size.
 524 const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 525   return IntegerType::get(C, getPointerSizeInBits());
 526 }
 527
 528
 529 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 530                                       unsigned NumIndices) const {
 531   const Type *Ty = ptrTy;
 532   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 533   uint64_t Result = 0;
 534
 535   generic_gep_type_iterator<Value* const*>
 536     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 537   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 538     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 539       assert(Indices[CurIDX]->getType() ==
 540              Type::getInt32Ty(ptrTy->getContext()) &&
 541              "Illegal struct idx");
 542       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 543
 544       // Get structure layout information...
 545       const StructLayout *Layout = getStructLayout(STy);
 546
 547       // Add in the offset, as calculated by the structure layout info...
 548       Result += Layout->getElementOffset(FieldNo);
 549
 550       // Update Ty to refer to current element
 551       Ty = STy->getElementType(FieldNo);
 552     } else {
 553       // Update Ty to refer to current element
 554       Ty = cast<SequentialType>(Ty)->getElementType();
 555
 556       // Get the array index and the size of each array element.
 557       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 558       Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
 559     }
 560   }
 561
 562   return Result;
 563 }
 564
 565 /// getPreferredAlignment - Return the preferred alignment of the specified
 566 /// global.  This includes an explicitly requested alignment (if the global
 567 /// has one).
 568 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 569   const Type *ElemType = GV->getType()->getElementType();
 570   unsigned Alignment = getPrefTypeAlignment(ElemType);
 571   if (GV->getAlignment() > Alignment)
 572     Alignment = GV->getAlignment();
 573
 574   if (GV->hasInitializer()) {
 575     if (Alignment < 16) {
 576       // If the global is not external, see if it is large.  If so, give it a
 577       // larger alignment.
 578       if (getTypeSizeInBits(ElemType) > 128)
 579         Alignment = 16;    // 16-byte alignment.
 580     }
 581   }
 582   return Alignment;
 583 }
 584
 585 /// getPreferredAlignmentLog - Return the preferred alignment of the
 586 /// specified global, returned in log form.  This includes an explicitly
 587 /// requested alignment (if the global has one).
 588 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 589   return Log2_32(getPreferredAlignment(GV));
 590 }