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     std::string arg0 = getToken(token, ":");
 188     const char *p = arg0.c_str();
 189     switch(*p) {
 190     case 'E':
 191       LittleEndian = false;
 192       break;
 193     case 'e':
 194       LittleEndian = true;
 195       break;
 196     case 'p':
 197       PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
 198       PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
 199       PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
 200       if (PointerPrefAlign == 0)
 201         PointerPrefAlign = PointerABIAlign;
 202       break;
 203     case 'i':
 204     case 'v':
 205     case 'f':
 206     case 'a': {
 207       AlignTypeEnum align_type =
 208         (*p == 'i' ? INTEGER_ALIGN : (*p == 'f' ? FLOAT_ALIGN :
 209            (*p == 'v' ? VECTOR_ALIGN : AGGREGATE_ALIGN)));
 210       uint32_t size = (uint32_t) atoi(++p);
 211       unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
 212       unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
 213       if (pref_align == 0)
 214         pref_align = abi_align;
 215       setAlignment(align_type, abi_align, pref_align, size);
 216       break;
 217     }
 218     default:
 219       break;
 220     }
 221   }
 222 }
 223
 224 TargetData::TargetData(const Module *M) {
 225   init(M->getDataLayout());
 226 }
 227
 228 void
 229 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
 230                          unsigned char pref_align, uint32_t bit_width) {
 231   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 232     if (Alignments[i].AlignType == align_type &&
 233         Alignments[i].TypeBitWidth == bit_width) {
 234       // Update the abi, preferred alignments.
 235       Alignments[i].ABIAlign = abi_align;
 236       Alignments[i].PrefAlign = pref_align;
 237       return;
 238     }
 239   }
 240
 241   Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 242                                             pref_align, bit_width));
 243 }
 244
 245 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
 246 /// preferred if ABIInfo = false) the target wants for the specified datatype.
 247 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
 248                                       uint32_t BitWidth, bool ABIInfo) const {
 249   // Check to see if we have an exact match and remember the best match we see.
 250   int BestMatchIdx = -1;
 251   int LargestInt = -1;
 252   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 253     if (Alignments[i].AlignType == AlignType &&
 254         Alignments[i].TypeBitWidth == BitWidth)
 255       return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 256
 257     // The best match so far depends on what we're looking for.
 258     if (AlignType == VECTOR_ALIGN) {
 259       // If this is a specification for a smaller vector type, we will fall back
 260       // to it.  This happens because <128 x double> can be implemented in terms
 261       // of 64 <2 x double>.
 262       if (Alignments[i].AlignType == VECTOR_ALIGN &&
 263           Alignments[i].TypeBitWidth < BitWidth) {
 264         // Verify that we pick the biggest of the fallbacks.
 265         if (BestMatchIdx == -1 ||
 266             Alignments[BestMatchIdx].TypeBitWidth < BitWidth)
 267           BestMatchIdx = i;
 268       }
 269     } else if (AlignType == INTEGER_ALIGN &&
 270                Alignments[i].AlignType == INTEGER_ALIGN) {
 271       // The "best match" for integers is the smallest size that is larger than
 272       // the BitWidth requested.
 273       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 274            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 275         BestMatchIdx = i;
 276       // However, if there isn't one that's larger, then we must use the
 277       // largest one we have (see below)
 278       if (LargestInt == -1 ||
 279           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 280         LargestInt = i;
 281     }
 282   }
 283
 284   // For integers, if we didn't find a best match, use the largest one found.
 285   if (BestMatchIdx == -1)
 286     BestMatchIdx = LargestInt;
 287
 288   // Okay, we didn't find an exact solution.  Fall back here depending on what
 289   // is being looked for.
 290   assert(BestMatchIdx != -1 && "Didn't find alignment info for this datatype!");
 291
 292   // Since we got a "best match" index, just return it.
 293   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 294                  : Alignments[BestMatchIdx].PrefAlign;
 295 }
 296
 297 /// LayoutInfo - The lazy cache of structure layout information maintained by
 298 /// TargetData.  Note that the struct types must have been free'd before
 299 /// llvm_shutdown is called (and thus this is deallocated) because all the
 300 /// targets with cached elements should have been destroyed.
 301 ///
 302 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
 303
 304 struct DenseMapLayoutKeyInfo {
 305   static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
 306   static inline LayoutKey getTombstoneKey() {
 307     return LayoutKey((TargetData*)(intptr_t)-1, 0);
 308   }
 309   static unsigned getHashValue(const LayoutKey &Val) {
 310     return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
 311            DenseMapKeyInfo<void*>::getHashValue(Val.second);
 312   }
 313   static bool isPod() { return true; }
 314 };
 315
 316 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
 317 static ManagedStatic<LayoutInfoTy> LayoutInfo;
 318
 319
 320 TargetData::~TargetData() {
 321   if (LayoutInfo.isConstructed()) {
 322     // Remove any layouts for this TD.
 323     LayoutInfoTy &TheMap = *LayoutInfo;
 324     for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
 325          I != E; ) {
 326       if (I->first.first == this) {
 327         I->second->~StructLayout();
 328         free(I->second);
 329         TheMap.erase(I++);
 330       } else {
 331         ++I;
 332       }
 333     }
 334   }
 335 }
 336
 337 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 338   LayoutInfoTy &TheMap = *LayoutInfo;
 339
 340   StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
 341   if (SL) return SL;
 342
 343   // Otherwise, create the struct layout.  Because it is variable length, we
 344   // malloc it, then use placement new.
 345   unsigned NumElts = Ty->getNumElements();
 346   StructLayout *L =
 347     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
 348
 349   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 350   // entries to be added to TheMap, invalidating our reference.
 351   SL = L;
 352
 353   new (L) StructLayout(Ty, *this);
 354   return L;
 355 }
 356
 357 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 358 /// objects.  If a TargetData object is alive when types are being refined and
 359 /// removed, this method must be called whenever a StructType is removed to
 360 /// avoid a dangling pointer in this cache.
 361 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 362   if (!LayoutInfo.isConstructed()) return;  // No cache.
 363
 364   LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
 365   if (I != LayoutInfo->end()) {
 366     I->second->~StructLayout();
 367     free(I->second);
 368     LayoutInfo->erase(I);
 369   }
 370 }
 371
 372
 373 std::string TargetData::getStringRepresentation() const {
 374   std::string repr;
 375   repr.append(LittleEndian ? "e" : "E");
 376   repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
 377       append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
 378       append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
 379   for (align_const_iterator I = Alignments.begin();
 380        I != Alignments.end();
 381        ++I) {
 382     repr.append("-").append(1, (char) I->AlignType).
 383       append(utostr((int64_t) I->TypeBitWidth)).
 384       append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
 385       append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
 386   }
 387   return repr;
 388 }
 389
 390
 391 uint64_t TargetData::getTypeSize(const Type *Ty) const {
 392   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 393   switch (Ty->getTypeID()) {
 394   case Type::LabelTyID:
 395   case Type::PointerTyID:
 396     return getPointerSize();
 397   case Type::ArrayTyID: {
 398     const ArrayType *ATy = cast<ArrayType>(Ty);
 399     uint64_t Size;
 400     unsigned char Alignment;
 401     Size = getTypeSize(ATy->getElementType());
 402     Alignment = getABITypeAlignment(ATy->getElementType());
 403     unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
 404     return AlignedSize*ATy->getNumElements();
 405   }
 406   case Type::StructTyID: {
 407     // Get the layout annotation... which is lazily created on demand.
 408     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 409     return Layout->getSizeInBytes();
 410   }
 411   case Type::IntegerTyID: {
 412     unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
 413     if (BitWidth <= 8) {
 414       return 1;
 415     } else if (BitWidth <= 16) {
 416       return 2;
 417     } else if (BitWidth <= 32) {
 418       return 4;
 419     } else if (BitWidth <= 64) {
 420       return 8;
 421     } else {
 422       // The size of this > 64 bit type is chosen as a multiple of the
 423       // preferred alignment of the largest "native" size the target supports.
 424       // We first obtain the the alignment info for this type and then compute
 425       // the next largest multiple of that size.
 426       uint64_t size = getAlignmentInfo(INTEGER_ALIGN, BitWidth, false) * 8;
 427       return (((BitWidth / (size)) + (BitWidth % size != 0)) * size) / 8;
 428     }
 429     break;
 430   }
 431   case Type::VoidTyID:
 432     return 1;
 433   case Type::FloatTyID:
 434     return 4;
 435   case Type::DoubleTyID:
 436     return 8;
 437   case Type::VectorTyID: {
 438     const VectorType *PTy = cast<VectorType>(Ty);
 439     return PTy->getBitWidth() / 8;
 440   }
 441   default:
 442     assert(0 && "TargetData::getTypeSize(): Unsupported type");
 443     break;
 444   }
 445   return 0;
 446 }
 447
 448 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 449   if (Ty->isInteger())
 450     return cast<IntegerType>(Ty)->getBitWidth();
 451   else
 452     return getTypeSize(Ty) * 8;
 453 }
 454
 455
 456 /*!
 457   \param abi_or_pref Flag that determines which alignment is returned. true
 458   returns the ABI alignment, false returns the preferred alignment.
 459   \param Ty The underlying type for which alignment is determined.
 460
 461   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 462   == false) for the requested type \a Ty.
 463  */
 464 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 465   int AlignType = -1;
 466
 467   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 468   switch (Ty->getTypeID()) {
 469   /* Early escape for the non-numeric types */
 470   case Type::LabelTyID:
 471   case Type::PointerTyID:
 472     return (abi_or_pref
 473             ? getPointerABIAlignment()
 474             : getPointerPrefAlignment());
 475   case Type::ArrayTyID:
 476     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 477
 478   case Type::StructTyID: {
 479     // Packed structure types always have an ABI alignment of one.
 480     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 481       return 1;
 482
 483     // Get the layout annotation... which is lazily created on demand.
 484     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 485     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref);
 486     return std::max(Align, (unsigned)Layout->getAlignment());
 487   }
 488   case Type::IntegerTyID:
 489   case Type::VoidTyID:
 490     AlignType = INTEGER_ALIGN;
 491     break;
 492   case Type::FloatTyID:
 493   case Type::DoubleTyID:
 494     AlignType = FLOAT_ALIGN;
 495     break;
 496   case Type::VectorTyID:
 497     AlignType = VECTOR_ALIGN;
 498     break;
 499   default:
 500     assert(0 && "Bad type for getAlignment!!!");
 501     break;
 502   }
 503
 504   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSize(Ty) * 8,
 505                           abi_or_pref);
 506 }
 507
 508 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 509   return getAlignment(Ty, true);
 510 }
 511
 512 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 513   return getAlignment(Ty, false);
 514 }
 515
 516 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 517   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 518   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 519   return Log2_32(Align);
 520 }
 521
 522 /// getIntPtrType - Return an unsigned integer type that is the same size or
 523 /// greater to the host pointer size.
 524 const Type *TargetData::getIntPtrType() const {
 525   switch (getPointerSize()) {
 526   default: assert(0 && "Unknown pointer size!");
 527   case 2: return Type::Int16Ty;
 528   case 4: return Type::Int32Ty;
 529   case 8: return Type::Int64Ty;
 530   }
 531 }
 532
 533
 534 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 535                                       unsigned NumIndices) const {
 536   const Type *Ty = ptrTy;
 537   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 538   uint64_t Result = 0;
 539
 540   generic_gep_type_iterator<Value* const*>
 541     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 542   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 543     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 544       assert(Indices[CurIDX]->getType() == Type::Int32Ty &&"Illegal struct idx");
 545       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 546
 547       // Get structure layout information...
 548       const StructLayout *Layout = getStructLayout(STy);
 549
 550       // Add in the offset, as calculated by the structure layout info...
 551       Result += Layout->getElementOffset(FieldNo);
 552
 553       // Update Ty to refer to current element
 554       Ty = STy->getElementType(FieldNo);
 555     } else {
 556       // Update Ty to refer to current element
 557       Ty = cast<SequentialType>(Ty)->getElementType();
 558
 559       // Get the array index and the size of each array element.
 560       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 561       Result += arrayIdx * (int64_t)getTypeSize(Ty);
 562     }
 563   }
 564
 565   return Result;
 566 }
 567
 568 /// getPreferredAlignmentLog - Return the preferred alignment of the
 569 /// specified global, returned in log form.  This includes an explicitly
 570 /// requested alignment (if the global has one).
 571 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 572   const Type *ElemType = GV->getType()->getElementType();
 573   unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
 574   if (GV->getAlignment() > (1U << Alignment))
 575     Alignment = Log2_32(GV->getAlignment());
 576
 577   if (GV->hasInitializer()) {
 578     if (Alignment < 4) {
 579       // If the global is not external, see if it is large.  If so, give it a
 580       // larger alignment.
 581       if (getTypeSize(ElemType) > 128)
 582         Alignment = 4;    // 16-byte alignment.
 583     }
 584   }
 585   return Alignment;
 586 }