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