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