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