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     StructSize = (StructSize + TyAlign - 1)/TyAlign * TyAlign;
  55
  56     // Keep track of maximum alignment constraint
  57     StructAlignment = std::max(TyAlign, StructAlignment);
  58
  59     MemberOffsets[i] = StructSize;
  60     StructSize += TD.getABITypeSize(Ty); // Consume space for this data item
  61   }
  62
  63   // Empty structures have alignment of 1 byte.
  64   if (StructAlignment == 0) StructAlignment = 1;
  65
  66   // Add padding to the end of the struct so that it could be put in an array
  67   // and all array elements would be aligned correctly.
  68   if (StructSize % StructAlignment != 0)
  69     StructSize = (StructSize/StructAlignment + 1) * StructAlignment;
  70 }
  71
  72
  73 /// getElementContainingOffset - Given a valid offset into the structure,
  74 /// return the structure index that contains it.
  75 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
  76   const uint64_t *SI =
  77     std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
  78   assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
  79   --SI;
  80   assert(*SI <= Offset && "upper_bound didn't work");
  81   assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
  82          (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
  83          "Upper bound didn't work!");
  84
  85   // Multiple fields can have the same offset if any of them are zero sized.
  86   // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
  87   // at the i32 element, because it is the last element at that offset.  This is
  88   // the right one to return, because anything after it will have a higher
  89   // offset, implying that this element is non-empty.
  90   return SI-&MemberOffsets[0];
  91 }
  92
  93 //===----------------------------------------------------------------------===//
  94 // TargetAlignElem, TargetAlign support
  95 //===----------------------------------------------------------------------===//
  96
  97 TargetAlignElem
  98 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
  99                      unsigned char pref_align, uint32_t bit_width) {
 100   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 101   TargetAlignElem retval;
 102   retval.AlignType = align_type;
 103   retval.ABIAlign = abi_align;
 104   retval.PrefAlign = pref_align;
 105   retval.TypeBitWidth = bit_width;
 106   return retval;
 107 }
 108
 109 bool
 110 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
 111   return (AlignType == rhs.AlignType
 112           && ABIAlign == rhs.ABIAlign
 113           && PrefAlign == rhs.PrefAlign
 114           && TypeBitWidth == rhs.TypeBitWidth);
 115 }
 116
 117 std::ostream &
 118 TargetAlignElem::dump(std::ostream &os) const {
 119   return os << AlignType
 120             << TypeBitWidth
 121             << ":" << (int) (ABIAlign * 8)
 122             << ":" << (int) (PrefAlign * 8);
 123 }
 124
 125 const TargetAlignElem TargetData::InvalidAlignmentElem =
 126                 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 127
 128 //===----------------------------------------------------------------------===//
 129 //                       TargetData Class Implementation
 130 //===----------------------------------------------------------------------===//
 131
 132 /*!
 133  A TargetDescription string consists of a sequence of hyphen-delimited
 134  specifiers for target endianness, pointer size and alignments, and various
 135  primitive type sizes and alignments. A typical string looks something like:
 136  <br><br>
 137  "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
 138  <br><br>
 139  (note: this string is not fully specified and is only an example.)
 140  \p
 141  Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
 142  below) dictates how a type will be aligned within an aggregate and when used
 143  as an argument.  Preferred alignment (pref_align, below) determines a type's
 144  alignment when emitted as a global.
 145  \p
 146  Specifier string details:
 147  <br><br>
 148  <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
 149  specifies a little-endian target data model.
 150  <br><br>
 151  <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
 152  ABI and preferred alignment.
 153  <br><br>
 154  <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
 155  alignment. Type is
 156  one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector (aka
 157  packed) or aggregate.  Size indicates the size, e.g., 32 or 64 bits.
 158  \p
 159  The default string, fully specified is:
 160  <br><br>
 161  "E-p:64:64:64-a0:0:0-f32:32:32-f64:0:64"
 162  "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:0:64"
 163  "-v64:64:64-v128:128:128"
 164  <br><br>
 165  Note that in the case of aggregates, 0 is the default ABI and preferred
 166  alignment. This is a special case, where the aggregate's computed worst-case
 167  alignment will be used.
 168  */
 169 void TargetData::init(const std::string &TargetDescription) {
 170   std::string temp = TargetDescription;
 171
 172   LittleEndian = false;
 173   PointerMemSize = 8;
 174   PointerABIAlign   = 8;
 175   PointerPrefAlign = PointerABIAlign;
 176
 177   // Default alignments
 178   setAlignment(INTEGER_ALIGN,   1,  1, 1);   // Bool
 179   setAlignment(INTEGER_ALIGN,   1,  1, 8);   // Byte
 180   setAlignment(INTEGER_ALIGN,   2,  2, 16);  // short
 181   setAlignment(INTEGER_ALIGN,   4,  4, 32);  // int
 182   setAlignment(INTEGER_ALIGN,   4,  8, 64);  // long
 183   setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 184   setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 185   setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32
 186   setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 187   setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct, union, class, ...
 188
 189   while (!temp.empty()) {
 190     std::string token = getToken(temp, "-");
 191     std::string arg0 = getToken(token, ":");
 192     const char *p = arg0.c_str();
 193     switch(*p) {
 194     case 'E':
 195       LittleEndian = false;
 196       break;
 197     case 'e':
 198       LittleEndian = true;
 199       break;
 200     case 'p':
 201       PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
 202       PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
 203       PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
 204       if (PointerPrefAlign == 0)
 205         PointerPrefAlign = PointerABIAlign;
 206       break;
 207     case 'i':
 208     case 'v':
 209     case 'f':
 210     case 'a':
 211     case 's': {
 212       AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
 213       switch(*p) {
 214         case 'i': align_type = INTEGER_ALIGN; break;
 215         case 'v': align_type = VECTOR_ALIGN; break;
 216         case 'f': align_type = FLOAT_ALIGN; break;
 217         case 'a': align_type = AGGREGATE_ALIGN; break;
 218         case 's': align_type = STACK_ALIGN; break;
 219       }
 220       uint32_t size = (uint32_t) atoi(++p);
 221       unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
 222       unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
 223       if (pref_align == 0)
 224         pref_align = abi_align;
 225       setAlignment(align_type, abi_align, pref_align, size);
 226       break;
 227     }
 228     default:
 229       break;
 230     }
 231   }
 232 }
 233
 234 TargetData::TargetData(const Module *M)
 235   : ImmutablePass((intptr_t)&ID) {
 236   init(M->getDataLayout());
 237 }
 238
 239 void
 240 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
 241                          unsigned char pref_align, uint32_t bit_width) {
 242   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 243   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 244     if (Alignments[i].AlignType == align_type &&
 245         Alignments[i].TypeBitWidth == bit_width) {
 246       // Update the abi, preferred alignments.
 247       Alignments[i].ABIAlign = abi_align;
 248       Alignments[i].PrefAlign = pref_align;
 249       return;
 250     }
 251   }
 252
 253   Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 254                                             pref_align, bit_width));
 255 }
 256
 257 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
 258 /// preferred if ABIInfo = false) the target wants for the specified datatype.
 259 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
 260                                       uint32_t BitWidth, bool ABIInfo,
 261                                       const Type *Ty) const {
 262   // Check to see if we have an exact match and remember the best match we see.
 263   int BestMatchIdx = -1;
 264   int LargestInt = -1;
 265   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 266     if (Alignments[i].AlignType == AlignType &&
 267         Alignments[i].TypeBitWidth == BitWidth)
 268       return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 269
 270     // The best match so far depends on what we're looking for.
 271     if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
 272       // If this is a specification for a smaller vector type, we will fall back
 273       // to it.  This happens because <128 x double> can be implemented in terms
 274       // of 64 <2 x double>.
 275       if (Alignments[i].TypeBitWidth < BitWidth) {
 276         // Verify that we pick the biggest of the fallbacks.
 277         if (BestMatchIdx == -1 ||
 278             Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
 279           BestMatchIdx = i;
 280       }
 281     } else if (AlignType == INTEGER_ALIGN &&
 282                Alignments[i].AlignType == INTEGER_ALIGN) {
 283       // The "best match" for integers is the smallest size that is larger than
 284       // the BitWidth requested.
 285       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 286            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 287         BestMatchIdx = i;
 288       // However, if there isn't one that's larger, then we must use the
 289       // largest one we have (see below)
 290       if (LargestInt == -1 ||
 291           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 292         LargestInt = i;
 293     }
 294   }
 295
 296   // Okay, we didn't find an exact solution.  Fall back here depending on what
 297   // is being looked for.
 298   if (BestMatchIdx == -1) {
 299     // If we didn't find an integer alignment, fall back on most conservative.
 300     if (AlignType == INTEGER_ALIGN) {
 301       BestMatchIdx = LargestInt;
 302     } else {
 303       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 304
 305       // If we didn't find a vector size that is smaller or equal to this type,
 306       // then we will end up scalarizing this to its element type.  Just return
 307       // the alignment of the element.
 308       return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
 309     }
 310   }
 311
 312   // Since we got a "best match" index, just return it.
 313   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 314                  : Alignments[BestMatchIdx].PrefAlign;
 315 }
 316
 317 namespace {
 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
 344 }
 345
 346 static ManagedStatic<LayoutInfoTy> LayoutInfo;
 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 }