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