contrib/llvm/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/Constants.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Module.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/Support/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 INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true)
  38 char TargetData::ID = 0;
  39
  40 //===----------------------------------------------------------------------===//
  41 // Support for StructLayout
  42 //===----------------------------------------------------------------------===//
  43
  44 StructLayout::StructLayout(StructType *ST, const TargetData &TD) {
  45   assert(!ST->isOpaque() && "Cannot get layout of opaque structs");
  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     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 abi_align,
 102                      unsigned 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 const TargetAlignElem TargetData::InvalidAlignmentElem =
 121                 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 122
 123 //===----------------------------------------------------------------------===//
 124 //                       TargetData Class Implementation
 125 //===----------------------------------------------------------------------===//
 126
 127 /// getInt - Get an integer ignoring errors.
 128 static unsigned getInt(StringRef R) {
 129   unsigned Result = 0;
 130   R.getAsInteger(10, Result);
 131   return Result;
 132 }
 133
 134 void TargetData::init(StringRef Desc) {
 135   initializeTargetDataPass(*PassRegistry::getPassRegistry());
 136
 137   LayoutMap = 0;
 138   LittleEndian = false;
 139   PointerMemSize = 8;
 140   PointerABIAlign = 8;
 141   PointerPrefAlign = PointerABIAlign;
 142   StackNaturalAlign = 0;
 143
 144   // Default alignments
 145   setAlignment(INTEGER_ALIGN,   1,  1, 1);   // i1
 146   setAlignment(INTEGER_ALIGN,   1,  1, 8);   // i8
 147   setAlignment(INTEGER_ALIGN,   2,  2, 16);  // i16
 148   setAlignment(INTEGER_ALIGN,   4,  4, 32);  // i32
 149   setAlignment(INTEGER_ALIGN,   4,  8, 64);  // i64
 150   setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 151   setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 152   setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32, v1i64, ...
 153   setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 154   setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct
 155
 156   while (!Desc.empty()) {
 157     std::pair<StringRef, StringRef> Split = Desc.split('-');
 158     StringRef Token = Split.first;
 159     Desc = Split.second;
 160
 161     if (Token.empty())
 162       continue;
 163
 164     Split = Token.split(':');
 165     StringRef Specifier = Split.first;
 166     Token = Split.second;
 167
 168     assert(!Specifier.empty() && "Can't be empty here");
 169
 170     switch (Specifier[0]) {
 171     case 'E':
 172       LittleEndian = false;
 173       break;
 174     case 'e':
 175       LittleEndian = true;
 176       break;
 177     case 'p':
 178       Split = Token.split(':');
 179       PointerMemSize = getInt(Split.first) / 8;
 180       Split = Split.second.split(':');
 181       PointerABIAlign = getInt(Split.first) / 8;
 182       Split = Split.second.split(':');
 183       PointerPrefAlign = getInt(Split.first) / 8;
 184       if (PointerPrefAlign == 0)
 185         PointerPrefAlign = PointerABIAlign;
 186       break;
 187     case 'i':
 188     case 'v':
 189     case 'f':
 190     case 'a':
 191     case 's': {
 192       AlignTypeEnum AlignType;
 193       switch (Specifier[0]) {
 194       default:
 195       case 'i': AlignType = INTEGER_ALIGN; break;
 196       case 'v': AlignType = VECTOR_ALIGN; break;
 197       case 'f': AlignType = FLOAT_ALIGN; break;
 198       case 'a': AlignType = AGGREGATE_ALIGN; break;
 199       case 's': AlignType = STACK_ALIGN; break;
 200       }
 201       unsigned Size = getInt(Specifier.substr(1));
 202       Split = Token.split(':');
 203       unsigned ABIAlign = getInt(Split.first) / 8;
 204
 205       Split = Split.second.split(':');
 206       unsigned PrefAlign = getInt(Split.first) / 8;
 207       if (PrefAlign == 0)
 208         PrefAlign = ABIAlign;
 209       setAlignment(AlignType, ABIAlign, PrefAlign, Size);
 210       break;
 211     }
 212     case 'n':  // Native integer types.
 213       Specifier = Specifier.substr(1);
 214       do {
 215         if (unsigned Width = getInt(Specifier))
 216           LegalIntWidths.push_back(Width);
 217         Split = Token.split(':');
 218         Specifier = Split.first;
 219         Token = Split.second;
 220       } while (!Specifier.empty() || !Token.empty());
 221       break;
 222     case 'S': // Stack natural alignment.
 223       StackNaturalAlign = getInt(Specifier.substr(1));
 224       StackNaturalAlign /= 8;
 225       // FIXME: Should we really be truncating these alingments and
 226       // sizes silently?
 227       break;
 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   report_fatal_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 abi_align,
 250                          unsigned 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                                       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 == INTEGER_ALIGN &&
 281          Alignments[i].AlignType == INTEGER_ALIGN) {
 282       // The "best match" for integers is the smallest size that is larger than
 283       // the BitWidth requested.
 284       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 285            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 286         BestMatchIdx = i;
 287       // However, if there isn't one that's larger, then we must use the
 288       // largest one we have (see below)
 289       if (LargestInt == -1 ||
 290           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 291         LargestInt = i;
 292     }
 293   }
 294
 295   // Okay, we didn't find an exact solution.  Fall back here depending on what
 296   // is being looked for.
 297   if (BestMatchIdx == -1) {
 298     // If we didn't find an integer alignment, fall back on most conservative.
 299     if (AlignType == INTEGER_ALIGN) {
 300       BestMatchIdx = LargestInt;
 301     } else {
 302       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 303
 304       // By default, use natural alignment for vector types. This is consistent
 305       // with what clang and llvm-gcc do.
 306       unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
 307       Align *= cast<VectorType>(Ty)->getNumElements();
 308       // If the alignment is not a power of 2, round up to the next power of 2.
 309       // This happens for non-power-of-2 length vectors.
 310       if (Align & (Align-1))
 311         Align = llvm::NextPowerOf2(Align);
 312       return Align;
 313     }
 314   }
 315
 316   // Since we got a "best match" index, just return it.
 317   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 318                  : Alignments[BestMatchIdx].PrefAlign;
 319 }
 320
 321 namespace {
 322
 323 class StructLayoutMap {
 324   typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy;
 325   LayoutInfoTy LayoutInfo;
 326
 327 public:
 328   virtual ~StructLayoutMap() {
 329     // Remove any layouts.
 330     for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end();
 331          I != E; ++I) {
 332       StructLayout *Value = I->second;
 333       Value->~StructLayout();
 334       free(Value);
 335     }
 336   }
 337
 338   StructLayout *&operator[](StructType *STy) {
 339     return LayoutInfo[STy];
 340   }
 341
 342   // for debugging...
 343   virtual void dump() const {}
 344 };
 345
 346 } // end anonymous namespace
 347
 348 TargetData::~TargetData() {
 349   delete static_cast<StructLayoutMap*>(LayoutMap);
 350 }
 351
 352 const StructLayout *TargetData::getStructLayout(StructType *Ty) const {
 353   if (!LayoutMap)
 354     LayoutMap = new StructLayoutMap();
 355
 356   StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
 357   StructLayout *&SL = (*STM)[Ty];
 358   if (SL) return SL;
 359
 360   // Otherwise, create the struct layout.  Because it is variable length, we
 361   // malloc it, then use placement new.
 362   int NumElts = Ty->getNumElements();
 363   StructLayout *L =
 364     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
 365
 366   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 367   // entries to be added to TheMap, invalidating our reference.
 368   SL = L;
 369
 370   new (L) StructLayout(Ty, *this);
 371
 372   return L;
 373 }
 374
 375 std::string TargetData::getStringRepresentation() const {
 376   std::string Result;
 377   raw_string_ostream OS(Result);
 378
 379   OS << (LittleEndian ? "e" : "E")
 380      << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
 381      << ':' << PointerPrefAlign*8
 382      << "-S" << StackNaturalAlign*8;
 383
 384   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 385     const TargetAlignElem &AI = Alignments[i];
 386     OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
 387        << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
 388   }
 389
 390   if (!LegalIntWidths.empty()) {
 391     OS << "-n" << (unsigned)LegalIntWidths[0];
 392
 393     for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
 394       OS << ':' << (unsigned)LegalIntWidths[i];
 395   }
 396   return OS.str();
 397 }
 398
 399
 400 uint64_t TargetData::getTypeSizeInBits(Type *Ty) const {
 401   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 402   switch (Ty->getTypeID()) {
 403   case Type::LabelTyID:
 404   case Type::PointerTyID:
 405     return getPointerSizeInBits();
 406   case Type::ArrayTyID: {
 407     ArrayType *ATy = cast<ArrayType>(Ty);
 408     return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
 409   }
 410   case Type::StructTyID:
 411     // Get the layout annotation... which is lazily created on demand.
 412     return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 413   case Type::IntegerTyID:
 414     return cast<IntegerType>(Ty)->getBitWidth();
 415   case Type::VoidTyID:
 416     return 8;
 417   case Type::FloatTyID:
 418     return 32;
 419   case Type::DoubleTyID:
 420   case Type::X86_MMXTyID:
 421     return 64;
 422   case Type::PPC_FP128TyID:
 423   case Type::FP128TyID:
 424     return 128;
 425   // In memory objects this is always aligned to a higher boundary, but
 426   // only 80 bits contain information.
 427   case Type::X86_FP80TyID:
 428     return 80;
 429   case Type::VectorTyID:
 430     return cast<VectorType>(Ty)->getBitWidth();
 431   default:
 432     llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 433     break;
 434   }
 435   return 0;
 436 }
 437
 438 /*!
 439   \param abi_or_pref Flag that determines which alignment is returned. true
 440   returns the ABI alignment, false returns the preferred alignment.
 441   \param Ty The underlying type for which alignment is determined.
 442
 443   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 444   == false) for the requested type \a Ty.
 445  */
 446 unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const {
 447   int AlignType = -1;
 448
 449   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 450   switch (Ty->getTypeID()) {
 451   // Early escape for the non-numeric types.
 452   case Type::LabelTyID:
 453   case Type::PointerTyID:
 454     return (abi_or_pref
 455             ? getPointerABIAlignment()
 456             : getPointerPrefAlignment());
 457   case Type::ArrayTyID:
 458     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 459
 460   case Type::StructTyID: {
 461     // Packed structure types always have an ABI alignment of one.
 462     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 463       return 1;
 464
 465     // Get the layout annotation... which is lazily created on demand.
 466     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 467     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 468     return std::max(Align, Layout->getAlignment());
 469   }
 470   case Type::IntegerTyID:
 471   case Type::VoidTyID:
 472     AlignType = INTEGER_ALIGN;
 473     break;
 474   case Type::FloatTyID:
 475   case Type::DoubleTyID:
 476   // PPC_FP128TyID and FP128TyID have different data contents, but the
 477   // same size and alignment, so they look the same here.
 478   case Type::PPC_FP128TyID:
 479   case Type::FP128TyID:
 480   case Type::X86_FP80TyID:
 481     AlignType = FLOAT_ALIGN;
 482     break;
 483   case Type::X86_MMXTyID:
 484   case Type::VectorTyID:
 485     AlignType = VECTOR_ALIGN;
 486     break;
 487   default:
 488     llvm_unreachable("Bad type for getAlignment!!!");
 489     break;
 490   }
 491
 492   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 493                           abi_or_pref, Ty);
 494 }
 495
 496 unsigned TargetData::getABITypeAlignment(Type *Ty) const {
 497   return getAlignment(Ty, true);
 498 }
 499
 500 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
 501 /// an integer type of the specified bitwidth.
 502 unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
 503   return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
 504 }
 505
 506
 507 unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const {
 508   for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 509     if (Alignments[i].AlignType == STACK_ALIGN)
 510       return Alignments[i].ABIAlign;
 511
 512   return getABITypeAlignment(Ty);
 513 }
 514
 515 unsigned TargetData::getPrefTypeAlignment(Type *Ty) const {
 516   return getAlignment(Ty, false);
 517 }
 518
 519 unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const {
 520   unsigned Align = getPrefTypeAlignment(Ty);
 521   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 522   return Log2_32(Align);
 523 }
 524
 525 /// getIntPtrType - Return an unsigned integer type that is the same size or
 526 /// greater to the host pointer size.
 527 IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 528   return IntegerType::get(C, getPointerSizeInBits());
 529 }
 530
 531
 532 uint64_t TargetData::getIndexedOffset(Type *ptrTy,
 533                                       ArrayRef<Value *> Indices) const {
 534   Type *Ty = ptrTy;
 535   assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
 536   uint64_t Result = 0;
 537
 538   generic_gep_type_iterator<Value* const*>
 539     TI = gep_type_begin(ptrTy, Indices);
 540   for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX;
 541        ++CurIDX, ++TI) {
 542     if (StructType *STy = dyn_cast<StructType>(*TI)) {
 543       assert(Indices[CurIDX]->getType() ==
 544              Type::getInt32Ty(ptrTy->getContext()) &&
 545              "Illegal struct idx");
 546       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 547
 548       // Get structure layout information...
 549       const StructLayout *Layout = getStructLayout(STy);
 550
 551       // Add in the offset, as calculated by the structure layout info...
 552       Result += Layout->getElementOffset(FieldNo);
 553
 554       // Update Ty to refer to current element
 555       Ty = STy->getElementType(FieldNo);
 556     } else {
 557       // Update Ty to refer to current element
 558       Ty = cast<SequentialType>(Ty)->getElementType();
 559
 560       // Get the array index and the size of each array element.
 561       if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
 562         Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
 563     }
 564   }
 565
 566   return Result;
 567 }
 568
 569 /// getPreferredAlignment - Return the preferred alignment of the specified
 570 /// global.  This includes an explicitly requested alignment (if the global
 571 /// has one).
 572 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 573   Type *ElemType = GV->getType()->getElementType();
 574   unsigned Alignment = getPrefTypeAlignment(ElemType);
 575   unsigned GVAlignment = GV->getAlignment();
 576   if (GVAlignment >= Alignment) {
 577     Alignment = GVAlignment;
 578   } else if (GVAlignment != 0) {
 579     Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType));
 580   }
 581
 582   if (GV->hasInitializer() && GVAlignment == 0) {
 583     if (Alignment < 16) {
 584       // If the global is not external, see if it is large.  If so, give it a
 585       // larger alignment.
 586       if (getTypeSizeInBits(ElemType) > 128)
 587         Alignment = 16;    // 16-byte alignment.
 588     }
 589   }
 590   return Alignment;
 591 }
 592
 593 /// getPreferredAlignmentLog - Return the preferred alignment of the
 594 /// specified global, returned in log form.  This includes an explicitly
 595 /// requested alignment (if the global has one).
 596 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 597   return Log2_32(getPreferredAlignment(GV));
 598 }