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