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