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