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