lib/Target/TargetData.cpp

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