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