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::PPC_FP128TyID:
 440   case Type::FP128TyID:
 441     return 16;
 442   // In memory objects this is always aligned to a higher boundary, but
 443   // only 10 bytes contain information.
 444   case Type::X86_FP80TyID:
 445     return 10;
 446   case Type::VectorTyID: {
 447     const VectorType *PTy = cast<VectorType>(Ty);
 448     return PTy->getBitWidth() / 8;
 449   }
 450   default:
 451     assert(0 && "TargetData::getTypeSize(): Unsupported type");
 452     break;
 453   }
 454   return 0;
 455 }
 456
 457 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 458   if (Ty->isInteger())
 459     return cast<IntegerType>(Ty)->getBitWidth();
 460   else
 461     return getTypeSize(Ty) * 8;
 462 }
 463
 464
 465 /*!
 466   \param abi_or_pref Flag that determines which alignment is returned. true
 467   returns the ABI alignment, false returns the preferred alignment.
 468   \param Ty The underlying type for which alignment is determined.
 469
 470   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 471   == false) for the requested type \a Ty.
 472  */
 473 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 474   int AlignType = -1;
 475
 476   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 477   switch (Ty->getTypeID()) {
 478   /* Early escape for the non-numeric types */
 479   case Type::LabelTyID:
 480   case Type::PointerTyID:
 481     return (abi_or_pref
 482             ? getPointerABIAlignment()
 483             : getPointerPrefAlignment());
 484   case Type::ArrayTyID:
 485     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 486
 487   case Type::StructTyID: {
 488     // Packed structure types always have an ABI alignment of one.
 489     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 490       return 1;
 491
 492     // Get the layout annotation... which is lazily created on demand.
 493     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 494     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
 495     return std::max(Align, (unsigned)Layout->getAlignment());
 496   }
 497   case Type::IntegerTyID:
 498   case Type::VoidTyID:
 499     AlignType = INTEGER_ALIGN;
 500     break;
 501   case Type::FloatTyID:
 502   case Type::DoubleTyID:
 503   // PPC_FP128TyID and FP128TyID have different data contents, but the
 504   // same size and alignment, so they look the same here.
 505   case Type::PPC_FP128TyID:
 506   case Type::FP128TyID:
 507   case Type::X86_FP80TyID:
 508     AlignType = FLOAT_ALIGN;
 509     break;
 510   case Type::VectorTyID: {
 511     const VectorType *VTy = cast<VectorType>(Ty);
 512     // Degenerate vectors are assumed to be scalar-ized
 513     if (VTy->getNumElements() == 1)
 514       return getAlignment(VTy->getElementType(), abi_or_pref);
 515     else
 516       AlignType = VECTOR_ALIGN;
 517     break;
 518   }
 519   default:
 520     assert(0 && "Bad type for getAlignment!!!");
 521     break;
 522   }
 523
 524   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSize(Ty) * 8,
 525                           abi_or_pref);
 526 }
 527
 528 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 529   return getAlignment(Ty, true);
 530 }
 531
 532 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 533   return getAlignment(Ty, false);
 534 }
 535
 536 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 537   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 538   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 539   return Log2_32(Align);
 540 }
 541
 542 /// getIntPtrType - Return an unsigned integer type that is the same size or
 543 /// greater to the host pointer size.
 544 const Type *TargetData::getIntPtrType() const {
 545   switch (getPointerSize()) {
 546   default: assert(0 && "Unknown pointer size!");
 547   case 2: return Type::Int16Ty;
 548   case 4: return Type::Int32Ty;
 549   case 8: return Type::Int64Ty;
 550   }
 551 }
 552
 553
 554 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 555                                       unsigned NumIndices) const {
 556   const Type *Ty = ptrTy;
 557   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 558   uint64_t Result = 0;
 559
 560   generic_gep_type_iterator<Value* const*>
 561     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 562   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 563     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 564       assert(Indices[CurIDX]->getType() == Type::Int32Ty &&
 565              "Illegal struct idx");
 566       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 567
 568       // Get structure layout information...
 569       const StructLayout *Layout = getStructLayout(STy);
 570
 571       // Add in the offset, as calculated by the structure layout info...
 572       Result += Layout->getElementOffset(FieldNo);
 573
 574       // Update Ty to refer to current element
 575       Ty = STy->getElementType(FieldNo);
 576     } else {
 577       // Update Ty to refer to current element
 578       Ty = cast<SequentialType>(Ty)->getElementType();
 579
 580       // Get the array index and the size of each array element.
 581       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 582       Result += arrayIdx * (int64_t)getTypeSize(Ty);
 583     }
 584   }
 585
 586   return Result;
 587 }
 588
 589 /// getPreferredAlignmentLog - Return the preferred alignment of the
 590 /// specified global, returned in log form.  This includes an explicitly
 591 /// requested alignment (if the global has one).
 592 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 593   const Type *ElemType = GV->getType()->getElementType();
 594   unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
 595   if (GV->getAlignment() > (1U << Alignment))
 596     Alignment = Log2_32(GV->getAlignment());
 597
 598   if (GV->hasInitializer()) {
 599     if (Alignment < 4) {
 600       // If the global is not external, see if it is large.  If so, give it a
 601       // larger alignment.
 602       if (getTypeSize(ElemType) > 128)
 603         Alignment = 4;    // 16-byte alignment.
 604     }
 605   }
 606   return Alignment;
 607 }