lib/Target/TargetData.cpp

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