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