lib/Target/TargetData.cpp

   1 //===-- TargetData.cpp - Data size & alignment routines --------------------==//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // 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/Support/ErrorHandling.h"
  27 #include "llvm/System/Mutex.h"
  28 #include "llvm/ADT/DenseMap.h"
  29 #include "llvm/ADT/StringExtras.h"
  30 #include <algorithm>
  31 #include <cstdlib>
  32 using namespace llvm;
  33
  34 // Handle the Pass registration stuff necessary to use TargetData's.
  35
  36 // Register the default SparcV9 implementation...
  37 static RegisterPass<TargetData> X("targetdata", "Target Data Layout", false,
  38                                   true);
  39 char TargetData::ID = 0;
  40
  41 //===----------------------------------------------------------------------===//
  42 // Support for StructLayout
  43 //===----------------------------------------------------------------------===//
  44
  45 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
  46   StructAlignment = 0;
  47   StructSize = 0;
  48   NumElements = ST->getNumElements();
  49
  50   // Loop over each of the elements, placing them in memory.
  51   for (unsigned i = 0, e = NumElements; i != e; ++i) {
  52     const Type *Ty = ST->getElementType(i);
  53     unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty);
  54
  55     // Add padding if necessary to align the data element properly.
  56     if ((StructSize & (TyAlign-1)) != 0)
  57       StructSize = TargetData::RoundUpAlignment(StructSize, TyAlign);
  58
  59     // Keep track of maximum alignment constraint.
  60     StructAlignment = std::max(TyAlign, StructAlignment);
  61
  62     MemberOffsets[i] = StructSize;
  63     StructSize += TD.getTypeAllocSize(Ty); // Consume space for this data item
  64   }
  65
  66   // Empty structures have alignment of 1 byte.
  67   if (StructAlignment == 0) StructAlignment = 1;
  68
  69   // Add padding to the end of the struct so that it could be put in an array
  70   // and all array elements would be aligned correctly.
  71   if ((StructSize & (StructAlignment-1)) != 0)
  72     StructSize = TargetData::RoundUpAlignment(StructSize, StructAlignment);
  73 }
  74
  75
  76 /// getElementContainingOffset - Given a valid offset into the structure,
  77 /// return the structure index that contains it.
  78 unsigned StructLayout::getElementContainingOffset(uint64_t Offset) const {
  79   const uint64_t *SI =
  80     std::upper_bound(&MemberOffsets[0], &MemberOffsets[NumElements], Offset);
  81   assert(SI != &MemberOffsets[0] && "Offset not in structure type!");
  82   --SI;
  83   assert(*SI <= Offset && "upper_bound didn't work");
  84   assert((SI == &MemberOffsets[0] || *(SI-1) <= Offset) &&
  85          (SI+1 == &MemberOffsets[NumElements] || *(SI+1) > Offset) &&
  86          "Upper bound didn't work!");
  87
  88   // Multiple fields can have the same offset if any of them are zero sized.
  89   // For example, in { i32, [0 x i32], i32 }, searching for offset 4 will stop
  90   // at the i32 element, because it is the last element at that offset.  This is
  91   // the right one to return, because anything after it will have a higher
  92   // offset, implying that this element is non-empty.
  93   return SI-&MemberOffsets[0];
  94 }
  95
  96 //===----------------------------------------------------------------------===//
  97 // TargetAlignElem, TargetAlign support
  98 //===----------------------------------------------------------------------===//
  99
 100 TargetAlignElem
 101 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
 102                      unsigned char pref_align, uint32_t bit_width) {
 103   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 104   TargetAlignElem retval;
 105   retval.AlignType = align_type;
 106   retval.ABIAlign = abi_align;
 107   retval.PrefAlign = pref_align;
 108   retval.TypeBitWidth = bit_width;
 109   return retval;
 110 }
 111
 112 bool
 113 TargetAlignElem::operator==(const TargetAlignElem &rhs) const {
 114   return (AlignType == rhs.AlignType
 115           && ABIAlign == rhs.ABIAlign
 116           && PrefAlign == rhs.PrefAlign
 117           && TypeBitWidth == rhs.TypeBitWidth);
 118 }
 119
 120 std::ostream &
 121 TargetAlignElem::dump(std::ostream &os) const {
 122   return os << AlignType
 123             << TypeBitWidth
 124             << ":" << (int) (ABIAlign * 8)
 125             << ":" << (int) (PrefAlign * 8);
 126 }
 127
 128 const TargetAlignElem TargetData::InvalidAlignmentElem =
 129                 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 130
 131 //===----------------------------------------------------------------------===//
 132 //                       TargetData Class Implementation
 133 //===----------------------------------------------------------------------===//
 134
 135 /*!
 136  A TargetDescription string consists of a sequence of hyphen-delimited
 137  specifiers for target endianness, pointer size and alignments, and various
 138  primitive type sizes and alignments. A typical string looks something like:
 139  <br><br>
 140  "E-p:32:32:32-i1:8:8-i8:8:8-i32:32:32-i64:32:64-f32:32:32-f64:32:64"
 141  <br><br>
 142  (note: this string is not fully specified and is only an example.)
 143  \p
 144  Alignments come in two flavors: ABI and preferred. ABI alignment (abi_align,
 145  below) dictates how a type will be aligned within an aggregate and when used
 146  as an argument.  Preferred alignment (pref_align, below) determines a type's
 147  alignment when emitted as a global.
 148  \p
 149  Specifier string details:
 150  <br><br>
 151  <i>[E|e]</i>: Endianness. "E" specifies a big-endian target data model, "e"
 152  specifies a little-endian target data model.
 153  <br><br>
 154  <i>p:@verbatim<size>:<abi_align>:<pref_align>@endverbatim</i>: Pointer size,
 155  ABI and preferred alignment.
 156  <br><br>
 157  <i>@verbatim<type><size>:<abi_align>:<pref_align>@endverbatim</i>: Numeric type
 158  alignment. Type is
 159  one of <i>i|f|v|a</i>, corresponding to integer, floating point, vector, or
 160  aggregate.  Size indicates the size, e.g., 32 or 64 bits.
 161  \p
 162  The default string, fully specified, is:
 163  <br><br>
 164  "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64"
 165  "-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64"
 166  "-v64:64:64-v128:128:128"
 167  <br><br>
 168  Note that in the case of aggregates, 0 is the default ABI and preferred
 169  alignment. This is a special case, where the aggregate's computed worst-case
 170  alignment will be used.
 171  */
 172 void TargetData::init(const std::string &TargetDescription) {
 173   std::string temp = TargetDescription;
 174
 175   LayoutMap = 0;
 176   LittleEndian = false;
 177   PointerMemSize = 8;
 178   PointerABIAlign   = 8;
 179   PointerPrefAlign = PointerABIAlign;
 180
 181   // Default alignments
 182   setAlignment(INTEGER_ALIGN,   1,  1, 1);   // i1
 183   setAlignment(INTEGER_ALIGN,   1,  1, 8);   // i8
 184   setAlignment(INTEGER_ALIGN,   2,  2, 16);  // i16
 185   setAlignment(INTEGER_ALIGN,   4,  4, 32);  // i32
 186   setAlignment(INTEGER_ALIGN,   4,  8, 64);  // i64
 187   setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 188   setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 189   setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32, v1i64, ...
 190   setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 191   setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct
 192
 193   while (!temp.empty()) {
 194     std::string token = getToken(temp, "-");
 195     std::string arg0 = getToken(token, ":");
 196     const char *p = arg0.c_str();
 197     switch(*p) {
 198     case 'E':
 199       LittleEndian = false;
 200       break;
 201     case 'e':
 202       LittleEndian = true;
 203       break;
 204     case 'p':
 205       PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
 206       PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
 207       PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
 208       if (PointerPrefAlign == 0)
 209         PointerPrefAlign = PointerABIAlign;
 210       break;
 211     case 'i':
 212     case 'v':
 213     case 'f':
 214     case 'a':
 215     case 's': {
 216       AlignTypeEnum align_type = STACK_ALIGN; // Dummy init, silence warning
 217       switch(*p) {
 218         case 'i': align_type = INTEGER_ALIGN; break;
 219         case 'v': align_type = VECTOR_ALIGN; break;
 220         case 'f': align_type = FLOAT_ALIGN; break;
 221         case 'a': align_type = AGGREGATE_ALIGN; break;
 222         case 's': align_type = STACK_ALIGN; break;
 223       }
 224       uint32_t size = (uint32_t) atoi(++p);
 225       unsigned char abi_align = atoi(getToken(token, ":").c_str()) / 8;
 226       unsigned char pref_align = atoi(getToken(token, ":").c_str()) / 8;
 227       if (pref_align == 0)
 228         pref_align = abi_align;
 229       setAlignment(align_type, abi_align, pref_align, size);
 230       break;
 231     }
 232     default:
 233       break;
 234     }
 235   }
 236 }
 237
 238 TargetData::TargetData(const Module *M)
 239   : ImmutablePass(&ID) {
 240   init(M->getDataLayout());
 241 }
 242
 243 void
 244 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
 245                          unsigned char pref_align, uint32_t bit_width) {
 246   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 247   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 248     if (Alignments[i].AlignType == align_type &&
 249         Alignments[i].TypeBitWidth == bit_width) {
 250       // Update the abi, preferred alignments.
 251       Alignments[i].ABIAlign = abi_align;
 252       Alignments[i].PrefAlign = pref_align;
 253       return;
 254     }
 255   }
 256
 257   Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 258                                             pref_align, bit_width));
 259 }
 260
 261 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
 262 /// preferred if ABIInfo = false) the target wants for the specified datatype.
 263 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
 264                                       uint32_t BitWidth, bool ABIInfo,
 265                                       const Type *Ty) const {
 266   // Check to see if we have an exact match and remember the best match we see.
 267   int BestMatchIdx = -1;
 268   int LargestInt = -1;
 269   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 270     if (Alignments[i].AlignType == AlignType &&
 271         Alignments[i].TypeBitWidth == BitWidth)
 272       return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 273
 274     // The best match so far depends on what we're looking for.
 275     if (AlignType == VECTOR_ALIGN && Alignments[i].AlignType == VECTOR_ALIGN) {
 276       // If this is a specification for a smaller vector type, we will fall back
 277       // to it.  This happens because <128 x double> can be implemented in terms
 278       // of 64 <2 x double>.
 279       if (Alignments[i].TypeBitWidth < BitWidth) {
 280         // Verify that we pick the biggest of the fallbacks.
 281         if (BestMatchIdx == -1 ||
 282             Alignments[BestMatchIdx].TypeBitWidth < Alignments[i].TypeBitWidth)
 283           BestMatchIdx = i;
 284       }
 285     } else if (AlignType == INTEGER_ALIGN &&
 286                Alignments[i].AlignType == INTEGER_ALIGN) {
 287       // The "best match" for integers is the smallest size that is larger than
 288       // the BitWidth requested.
 289       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 290            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 291         BestMatchIdx = i;
 292       // However, if there isn't one that's larger, then we must use the
 293       // largest one we have (see below)
 294       if (LargestInt == -1 ||
 295           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 296         LargestInt = i;
 297     }
 298   }
 299
 300   // Okay, we didn't find an exact solution.  Fall back here depending on what
 301   // is being looked for.
 302   if (BestMatchIdx == -1) {
 303     // If we didn't find an integer alignment, fall back on most conservative.
 304     if (AlignType == INTEGER_ALIGN) {
 305       BestMatchIdx = LargestInt;
 306     } else {
 307       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 308
 309       // If we didn't find a vector size that is smaller or equal to this type,
 310       // then we will end up scalarizing this to its element type.  Just return
 311       // the alignment of the element.
 312       return getAlignment(cast<VectorType>(Ty)->getElementType(), ABIInfo);
 313     }
 314   }
 315
 316   // Since we got a "best match" index, just return it.
 317   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 318                  : Alignments[BestMatchIdx].PrefAlign;
 319 }
 320
 321 typedef DenseMap<const StructType*, StructLayout*>LayoutInfoTy;
 322
 323 TargetData::~TargetData() {
 324   if (!LayoutMap)
 325     return;
 326
 327   // Remove any layouts for this TD.
 328   LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
 329   for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end(); I != E; ) {
 330     I->second->~StructLayout();
 331     free(I->second);
 332     TheMap.erase(I++);
 333   }
 334
 335   delete static_cast<LayoutInfoTy*>(LayoutMap);
 336 }
 337
 338 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 339   if (!LayoutMap)
 340     LayoutMap = static_cast<void*>(new LayoutInfoTy());
 341
 342   LayoutInfoTy &TheMap = *static_cast<LayoutInfoTy*>(LayoutMap);
 343
 344   StructLayout *&SL = TheMap[Ty];
 345   if (SL) return SL;
 346
 347   // Otherwise, create the struct layout.  Because it is variable length, we
 348   // malloc it, then use placement new.
 349   int NumElts = Ty->getNumElements();
 350   StructLayout *L =
 351     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
 352
 353   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 354   // entries to be added to TheMap, invalidating our reference.
 355   SL = L;
 356
 357   new (L) StructLayout(Ty, *this);
 358   return L;
 359 }
 360
 361 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 362 /// objects.  If a TargetData object is alive when types are being refined and
 363 /// removed, this method must be called whenever a StructType is removed to
 364 /// avoid a dangling pointer in this cache.
 365 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 366   if (!LayoutMap) return;  // No cache.
 367
 368   LayoutInfoTy* LayoutInfo = static_cast<LayoutInfoTy*>(LayoutMap);
 369   LayoutInfoTy::iterator I = LayoutInfo->find(Ty);
 370   if (I == LayoutInfo->end()) return;
 371
 372   I->second->~StructLayout();
 373   free(I->second);
 374   LayoutInfo->erase(I);
 375 }
 376
 377
 378 std::string TargetData::getStringRepresentation() const {
 379   std::string repr;
 380   repr.append(LittleEndian ? "e" : "E");
 381   repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
 382       append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
 383       append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
 384   for (align_const_iterator I = Alignments.begin();
 385        I != Alignments.end();
 386        ++I) {
 387     repr.append("-").append(1, (char) I->AlignType).
 388       append(utostr((int64_t) I->TypeBitWidth)).
 389       append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
 390       append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
 391   }
 392   return repr;
 393 }
 394
 395
 396 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 397   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 398   switch (Ty->getTypeID()) {
 399   case Type::LabelTyID:
 400   case Type::PointerTyID:
 401     return getPointerSizeInBits();
 402   case Type::ArrayTyID: {
 403     const ArrayType *ATy = cast<ArrayType>(Ty);
 404     return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
 405   }
 406   case Type::StructTyID:
 407     // Get the layout annotation... which is lazily created on demand.
 408     return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 409   case Type::IntegerTyID:
 410     return cast<IntegerType>(Ty)->getBitWidth();
 411   case Type::VoidTyID:
 412     return 8;
 413   case Type::FloatTyID:
 414     return 32;
 415   case Type::DoubleTyID:
 416     return 64;
 417   case Type::PPC_FP128TyID:
 418   case Type::FP128TyID:
 419     return 128;
 420   // In memory objects this is always aligned to a higher boundary, but
 421   // only 80 bits contain information.
 422   case Type::X86_FP80TyID:
 423     return 80;
 424   case Type::VectorTyID:
 425     return cast<VectorType>(Ty)->getBitWidth();
 426   default:
 427     llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 428     break;
 429   }
 430   return 0;
 431 }
 432
 433 /*!
 434   \param abi_or_pref Flag that determines which alignment is returned. true
 435   returns the ABI alignment, false returns the preferred alignment.
 436   \param Ty The underlying type for which alignment is determined.
 437
 438   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 439   == false) for the requested type \a Ty.
 440  */
 441 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 442   int AlignType = -1;
 443
 444   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 445   switch (Ty->getTypeID()) {
 446   // Early escape for the non-numeric types.
 447   case Type::LabelTyID:
 448   case Type::PointerTyID:
 449     return (abi_or_pref
 450             ? getPointerABIAlignment()
 451             : getPointerPrefAlignment());
 452   case Type::ArrayTyID:
 453     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 454
 455   case Type::StructTyID: {
 456     // Packed structure types always have an ABI alignment of one.
 457     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 458       return 1;
 459
 460     // Get the layout annotation... which is lazily created on demand.
 461     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 462     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 463     return std::max(Align, (unsigned)Layout->getAlignment());
 464   }
 465   case Type::IntegerTyID:
 466   case Type::VoidTyID:
 467     AlignType = INTEGER_ALIGN;
 468     break;
 469   case Type::FloatTyID:
 470   case Type::DoubleTyID:
 471   // PPC_FP128TyID and FP128TyID have different data contents, but the
 472   // same size and alignment, so they look the same here.
 473   case Type::PPC_FP128TyID:
 474   case Type::FP128TyID:
 475   case Type::X86_FP80TyID:
 476     AlignType = FLOAT_ALIGN;
 477     break;
 478   case Type::VectorTyID:
 479     AlignType = VECTOR_ALIGN;
 480     break;
 481   default:
 482     llvm_unreachable("Bad type for getAlignment!!!");
 483     break;
 484   }
 485
 486   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 487                           abi_or_pref, Ty);
 488 }
 489
 490 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 491   return getAlignment(Ty, true);
 492 }
 493
 494 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
 495   for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 496     if (Alignments[i].AlignType == STACK_ALIGN)
 497       return Alignments[i].ABIAlign;
 498
 499   return getABITypeAlignment(Ty);
 500 }
 501
 502 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 503   return getAlignment(Ty, false);
 504 }
 505
 506 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 507   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 508   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 509   return Log2_32(Align);
 510 }
 511
 512 /// getIntPtrType - Return an unsigned integer type that is the same size or
 513 /// greater to the host pointer size.
 514 const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 515   return IntegerType::get(C, getPointerSizeInBits());
 516 }
 517
 518
 519 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 520                                       unsigned NumIndices) const {
 521   const Type *Ty = ptrTy;
 522   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 523   uint64_t Result = 0;
 524
 525   generic_gep_type_iterator<Value* const*>
 526     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 527   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 528     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 529       assert(Indices[CurIDX]->getType() ==
 530              Type::getInt32Ty(ptrTy->getContext()) &&
 531              "Illegal struct idx");
 532       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 533
 534       // Get structure layout information...
 535       const StructLayout *Layout = getStructLayout(STy);
 536
 537       // Add in the offset, as calculated by the structure layout info...
 538       Result += Layout->getElementOffset(FieldNo);
 539
 540       // Update Ty to refer to current element
 541       Ty = STy->getElementType(FieldNo);
 542     } else {
 543       // Update Ty to refer to current element
 544       Ty = cast<SequentialType>(Ty)->getElementType();
 545
 546       // Get the array index and the size of each array element.
 547       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 548       Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
 549     }
 550   }
 551
 552   return Result;
 553 }
 554
 555 /// getPreferredAlignment - Return the preferred alignment of the specified
 556 /// global.  This includes an explicitly requested alignment (if the global
 557 /// has one).
 558 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 559   const Type *ElemType = GV->getType()->getElementType();
 560   unsigned Alignment = getPrefTypeAlignment(ElemType);
 561   if (GV->getAlignment() > Alignment)
 562     Alignment = GV->getAlignment();
 563
 564   if (GV->hasInitializer()) {
 565     if (Alignment < 16) {
 566       // If the global is not external, see if it is large.  If so, give it a
 567       // larger alignment.
 568       if (getTypeSizeInBits(ElemType) > 128)
 569         Alignment = 16;    // 16-byte alignment.
 570     }
 571   }
 572   return Alignment;
 573 }
 574
 575 /// getPreferredAlignmentLog - Return the preferred alignment of the
 576 /// specified global, returned in log form.  This includes an explicitly
 577 /// requested alignment (if the global has one).
 578 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 579   return Log2_32(getPreferredAlignment(GV));
 580 }