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