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/Constants.h"
  21 #include "llvm/DerivedTypes.h"
  22 #include "llvm/Module.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/Support/raw_ostream.h"
  28 #include "llvm/System/Mutex.h"
  29 #include "llvm/ADT/DenseMap.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 INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, 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 abi_align,
 101                      unsigned 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 const TargetAlignElem TargetData::InvalidAlignmentElem =
 120                 TargetAlignElem::get((AlignTypeEnum) -1, 0, 0, 0);
 121
 122 //===----------------------------------------------------------------------===//
 123 //                       TargetData Class Implementation
 124 //===----------------------------------------------------------------------===//
 125
 126 /// getInt - Get an integer ignoring errors.
 127 static unsigned getInt(StringRef R) {
 128   unsigned Result = 0;
 129   R.getAsInteger(10, Result);
 130   return Result;
 131 }
 132
 133 void TargetData::init(StringRef Desc) {
 134   initializeTargetDataPass(*PassRegistry::getPassRegistry());
 135
 136   LayoutMap = 0;
 137   LittleEndian = false;
 138   PointerMemSize = 8;
 139   PointerABIAlign = 8;
 140   PointerPrefAlign = PointerABIAlign;
 141
 142   // Default alignments
 143   setAlignment(INTEGER_ALIGN,   1,  1, 1);   // i1
 144   setAlignment(INTEGER_ALIGN,   1,  1, 8);   // i8
 145   setAlignment(INTEGER_ALIGN,   2,  2, 16);  // i16
 146   setAlignment(INTEGER_ALIGN,   4,  4, 32);  // i32
 147   setAlignment(INTEGER_ALIGN,   4,  8, 64);  // i64
 148   setAlignment(FLOAT_ALIGN,     4,  4, 32);  // float
 149   setAlignment(FLOAT_ALIGN,     8,  8, 64);  // double
 150   setAlignment(VECTOR_ALIGN,    8,  8, 64);  // v2i32, v1i64, ...
 151   setAlignment(VECTOR_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 152   setAlignment(AGGREGATE_ALIGN, 0,  8,  0);  // struct
 153
 154   while (!Desc.empty()) {
 155     std::pair<StringRef, StringRef> Split = Desc.split('-');
 156     StringRef Token = Split.first;
 157     Desc = Split.second;
 158
 159     if (Token.empty())
 160       continue;
 161
 162     Split = Token.split(':');
 163     StringRef Specifier = Split.first;
 164     Token = Split.second;
 165
 166     assert(!Specifier.empty() && "Can't be empty here");
 167
 168     switch (Specifier[0]) {
 169     case 'E':
 170       LittleEndian = false;
 171       break;
 172     case 'e':
 173       LittleEndian = true;
 174       break;
 175     case 'p':
 176       Split = Token.split(':');
 177       PointerMemSize = getInt(Split.first) / 8;
 178       Split = Split.second.split(':');
 179       PointerABIAlign = getInt(Split.first) / 8;
 180       Split = Split.second.split(':');
 181       PointerPrefAlign = getInt(Split.first) / 8;
 182       if (PointerPrefAlign == 0)
 183         PointerPrefAlign = PointerABIAlign;
 184       break;
 185     case 'i':
 186     case 'v':
 187     case 'f':
 188     case 'a':
 189     case 's': {
 190       AlignTypeEnum AlignType;
 191       switch (Specifier[0]) {
 192       default:
 193       case 'i': AlignType = INTEGER_ALIGN; break;
 194       case 'v': AlignType = VECTOR_ALIGN; break;
 195       case 'f': AlignType = FLOAT_ALIGN; break;
 196       case 'a': AlignType = AGGREGATE_ALIGN; break;
 197       case 's': AlignType = STACK_ALIGN; break;
 198       }
 199       unsigned Size = getInt(Specifier.substr(1));
 200       Split = Token.split(':');
 201       unsigned ABIAlign = getInt(Split.first) / 8;
 202
 203       Split = Split.second.split(':');
 204       unsigned PrefAlign = getInt(Split.first) / 8;
 205       if (PrefAlign == 0)
 206         PrefAlign = ABIAlign;
 207       setAlignment(AlignType, ABIAlign, PrefAlign, Size);
 208       break;
 209     }
 210     case 'n':  // Native integer types.
 211       Specifier = Specifier.substr(1);
 212       do {
 213         if (unsigned Width = getInt(Specifier))
 214           LegalIntWidths.push_back(Width);
 215         Split = Token.split(':');
 216         Specifier = Split.first;
 217         Token = Split.second;
 218       } while (!Specifier.empty() || !Token.empty());
 219       break;
 220
 221     default:
 222       break;
 223     }
 224   }
 225 }
 226
 227 /// Default ctor.
 228 ///
 229 /// @note This has to exist, because this is a pass, but it should never be
 230 /// used.
 231 TargetData::TargetData() : ImmutablePass(ID) {
 232   report_fatal_error("Bad TargetData ctor used.  "
 233                     "Tool did not specify a TargetData to use?");
 234 }
 235
 236 TargetData::TargetData(const Module *M)
 237   : ImmutablePass(ID) {
 238   init(M->getDataLayout());
 239 }
 240
 241 void
 242 TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align,
 243                          unsigned pref_align, uint32_t bit_width) {
 244   assert(abi_align <= pref_align && "Preferred alignment worse than ABI!");
 245   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 246     if (Alignments[i].AlignType == align_type &&
 247         Alignments[i].TypeBitWidth == bit_width) {
 248       // Update the abi, preferred alignments.
 249       Alignments[i].ABIAlign = abi_align;
 250       Alignments[i].PrefAlign = pref_align;
 251       return;
 252     }
 253   }
 254
 255   Alignments.push_back(TargetAlignElem::get(align_type, abi_align,
 256                                             pref_align, bit_width));
 257 }
 258
 259 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or
 260 /// preferred if ABIInfo = false) the target wants for the specified datatype.
 261 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType,
 262                                       uint32_t BitWidth, bool ABIInfo,
 263                                       const Type *Ty) const {
 264   // Check to see if we have an exact match and remember the best match we see.
 265   int BestMatchIdx = -1;
 266   int LargestInt = -1;
 267   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 268     if (Alignments[i].AlignType == AlignType &&
 269         Alignments[i].TypeBitWidth == BitWidth)
 270       return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign;
 271
 272     // The best match so far depends on what we're looking for.
 273      if (AlignType == INTEGER_ALIGN &&
 274          Alignments[i].AlignType == INTEGER_ALIGN) {
 275       // The "best match" for integers is the smallest size that is larger than
 276       // the BitWidth requested.
 277       if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 ||
 278            Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth))
 279         BestMatchIdx = i;
 280       // However, if there isn't one that's larger, then we must use the
 281       // largest one we have (see below)
 282       if (LargestInt == -1 ||
 283           Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth)
 284         LargestInt = i;
 285     }
 286   }
 287
 288   // Okay, we didn't find an exact solution.  Fall back here depending on what
 289   // is being looked for.
 290   if (BestMatchIdx == -1) {
 291     // If we didn't find an integer alignment, fall back on most conservative.
 292     if (AlignType == INTEGER_ALIGN) {
 293       BestMatchIdx = LargestInt;
 294     } else {
 295       assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!");
 296
 297       // By default, use natural alignment for vector types. This is consistent
 298       // with what clang and llvm-gcc do.
 299       unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType());
 300       Align *= cast<VectorType>(Ty)->getNumElements();
 301       // If the alignment is not a power of 2, round up to the next power of 2.
 302       // This happens for non-power-of-2 length vectors.
 303       if (Align & (Align-1))
 304         Align = llvm::NextPowerOf2(Align);
 305       return Align;
 306     }
 307   }
 308
 309   // Since we got a "best match" index, just return it.
 310   return ABIInfo ? Alignments[BestMatchIdx].ABIAlign
 311                  : Alignments[BestMatchIdx].PrefAlign;
 312 }
 313
 314 namespace {
 315
 316 class StructLayoutMap : public AbstractTypeUser {
 317   typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
 318   LayoutInfoTy LayoutInfo;
 319
 320   void RemoveEntry(LayoutInfoTy::iterator I, bool WasAbstract) {
 321     I->second->~StructLayout();
 322     free(I->second);
 323     if (WasAbstract)
 324       I->first->removeAbstractTypeUser(this);
 325     LayoutInfo.erase(I);
 326   }
 327
 328
 329   /// refineAbstractType - The callback method invoked when an abstract type is
 330   /// resolved to another type.  An object must override this method to update
 331   /// its internal state to reference NewType instead of OldType.
 332   ///
 333   virtual void refineAbstractType(const DerivedType *OldTy,
 334                                   const Type *) {
 335     LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(OldTy));
 336     assert(I != LayoutInfo.end() && "Using type but not in map?");
 337     RemoveEntry(I, true);
 338   }
 339
 340   /// typeBecameConcrete - The other case which AbstractTypeUsers must be aware
 341   /// of is when a type makes the transition from being abstract (where it has
 342   /// clients on its AbstractTypeUsers list) to concrete (where it does not).
 343   /// This method notifies ATU's when this occurs for a type.
 344   ///
 345   virtual void typeBecameConcrete(const DerivedType *AbsTy) {
 346     LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(AbsTy));
 347     assert(I != LayoutInfo.end() && "Using type but not in map?");
 348     RemoveEntry(I, true);
 349   }
 350
 351 public:
 352   virtual ~StructLayoutMap() {
 353     // Remove any layouts.
 354     for (LayoutInfoTy::iterator
 355            I = LayoutInfo.begin(), E = LayoutInfo.end(); I != E; ++I) {
 356       const Type *Key = I->first;
 357       StructLayout *Value = I->second;
 358
 359       if (Key->isAbstract())
 360         Key->removeAbstractTypeUser(this);
 361
 362       Value->~StructLayout();
 363       free(Value);
 364     }
 365   }
 366
 367   void InvalidateEntry(const StructType *Ty) {
 368     LayoutInfoTy::iterator I = LayoutInfo.find(Ty);
 369     if (I == LayoutInfo.end()) return;
 370     RemoveEntry(I, Ty->isAbstract());
 371   }
 372
 373   StructLayout *&operator[](const StructType *STy) {
 374     return LayoutInfo[STy];
 375   }
 376
 377   // for debugging...
 378   virtual void dump() const {}
 379 };
 380
 381 } // end anonymous namespace
 382
 383 TargetData::~TargetData() {
 384   delete static_cast<StructLayoutMap*>(LayoutMap);
 385 }
 386
 387 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 388   if (!LayoutMap)
 389     LayoutMap = new StructLayoutMap();
 390
 391   StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
 392   StructLayout *&SL = (*STM)[Ty];
 393   if (SL) return SL;
 394
 395   // Otherwise, create the struct layout.  Because it is variable length, we
 396   // malloc it, then use placement new.
 397   int NumElts = Ty->getNumElements();
 398   StructLayout *L =
 399     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
 400
 401   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 402   // entries to be added to TheMap, invalidating our reference.
 403   SL = L;
 404
 405   new (L) StructLayout(Ty, *this);
 406
 407   if (Ty->isAbstract())
 408     Ty->addAbstractTypeUser(STM);
 409
 410   return L;
 411 }
 412
 413 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 414 /// objects.  If a TargetData object is alive when types are being refined and
 415 /// removed, this method must be called whenever a StructType is removed to
 416 /// avoid a dangling pointer in this cache.
 417 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 418   if (!LayoutMap) return;  // No cache.
 419
 420   static_cast<StructLayoutMap*>(LayoutMap)->InvalidateEntry(Ty);
 421 }
 422
 423 std::string TargetData::getStringRepresentation() const {
 424   std::string Result;
 425   raw_string_ostream OS(Result);
 426
 427   OS << (LittleEndian ? "e" : "E")
 428      << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
 429      << ':' << PointerPrefAlign*8;
 430   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 431     const TargetAlignElem &AI = Alignments[i];
 432     OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
 433        << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
 434   }
 435
 436   if (!LegalIntWidths.empty()) {
 437     OS << "-n" << (unsigned)LegalIntWidths[0];
 438
 439     for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
 440       OS << ':' << (unsigned)LegalIntWidths[i];
 441   }
 442   return OS.str();
 443 }
 444
 445
 446 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 447   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 448   switch (Ty->getTypeID()) {
 449   case Type::LabelTyID:
 450   case Type::PointerTyID:
 451     return getPointerSizeInBits();
 452   case Type::ArrayTyID: {
 453     const ArrayType *ATy = cast<ArrayType>(Ty);
 454     return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements();
 455   }
 456   case Type::StructTyID:
 457     // Get the layout annotation... which is lazily created on demand.
 458     return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 459   case Type::IntegerTyID:
 460     return cast<IntegerType>(Ty)->getBitWidth();
 461   case Type::VoidTyID:
 462     return 8;
 463   case Type::FloatTyID:
 464     return 32;
 465   case Type::DoubleTyID:
 466   case Type::X86_MMXTyID:
 467     return 64;
 468   case Type::PPC_FP128TyID:
 469   case Type::FP128TyID:
 470     return 128;
 471   // In memory objects this is always aligned to a higher boundary, but
 472   // only 80 bits contain information.
 473   case Type::X86_FP80TyID:
 474     return 80;
 475   case Type::VectorTyID:
 476     return cast<VectorType>(Ty)->getBitWidth();
 477   default:
 478     llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 479     break;
 480   }
 481   return 0;
 482 }
 483
 484 /*!
 485   \param abi_or_pref Flag that determines which alignment is returned. true
 486   returns the ABI alignment, false returns the preferred alignment.
 487   \param Ty The underlying type for which alignment is determined.
 488
 489   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 490   == false) for the requested type \a Ty.
 491  */
 492 unsigned TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 493   int AlignType = -1;
 494
 495   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 496   switch (Ty->getTypeID()) {
 497   // Early escape for the non-numeric types.
 498   case Type::LabelTyID:
 499   case Type::PointerTyID:
 500     return (abi_or_pref
 501             ? getPointerABIAlignment()
 502             : getPointerPrefAlignment());
 503   case Type::ArrayTyID:
 504     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 505
 506   case Type::StructTyID: {
 507     // Packed structure types always have an ABI alignment of one.
 508     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 509       return 1;
 510
 511     // Get the layout annotation... which is lazily created on demand.
 512     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 513     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 514     return std::max(Align, Layout->getAlignment());
 515   }
 516   case Type::IntegerTyID:
 517   case Type::VoidTyID:
 518     AlignType = INTEGER_ALIGN;
 519     break;
 520   case Type::FloatTyID:
 521   case Type::DoubleTyID:
 522   // PPC_FP128TyID and FP128TyID have different data contents, but the
 523   // same size and alignment, so they look the same here.
 524   case Type::PPC_FP128TyID:
 525   case Type::FP128TyID:
 526   case Type::X86_FP80TyID:
 527     AlignType = FLOAT_ALIGN;
 528     break;
 529   case Type::X86_MMXTyID:
 530   case Type::VectorTyID:
 531     AlignType = VECTOR_ALIGN;
 532     break;
 533   default:
 534     llvm_unreachable("Bad type for getAlignment!!!");
 535     break;
 536   }
 537
 538   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 539                           abi_or_pref, Ty);
 540 }
 541
 542 unsigned TargetData::getABITypeAlignment(const Type *Ty) const {
 543   return getAlignment(Ty, true);
 544 }
 545
 546 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
 547 /// an integer type of the specified bitwidth.
 548 unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
 549   return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
 550 }
 551
 552
 553 unsigned TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
 554   for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 555     if (Alignments[i].AlignType == STACK_ALIGN)
 556       return Alignments[i].ABIAlign;
 557
 558   return getABITypeAlignment(Ty);
 559 }
 560
 561 unsigned TargetData::getPrefTypeAlignment(const Type *Ty) const {
 562   return getAlignment(Ty, false);
 563 }
 564
 565 unsigned TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 566   unsigned Align = getPrefTypeAlignment(Ty);
 567   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 568   return Log2_32(Align);
 569 }
 570
 571 /// getIntPtrType - Return an unsigned integer type that is the same size or
 572 /// greater to the host pointer size.
 573 const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 574   return IntegerType::get(C, getPointerSizeInBits());
 575 }
 576
 577
 578 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 579                                       unsigned NumIndices) const {
 580   const Type *Ty = ptrTy;
 581   assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
 582   uint64_t Result = 0;
 583
 584   generic_gep_type_iterator<Value* const*>
 585     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 586   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 587     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 588       assert(Indices[CurIDX]->getType() ==
 589              Type::getInt32Ty(ptrTy->getContext()) &&
 590              "Illegal struct idx");
 591       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 592
 593       // Get structure layout information...
 594       const StructLayout *Layout = getStructLayout(STy);
 595
 596       // Add in the offset, as calculated by the structure layout info...
 597       Result += Layout->getElementOffset(FieldNo);
 598
 599       // Update Ty to refer to current element
 600       Ty = STy->getElementType(FieldNo);
 601     } else {
 602       // Update Ty to refer to current element
 603       Ty = cast<SequentialType>(Ty)->getElementType();
 604
 605       // Get the array index and the size of each array element.
 606       if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue())
 607         Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty);
 608     }
 609   }
 610
 611   return Result;
 612 }
 613
 614 /// getPreferredAlignment - Return the preferred alignment of the specified
 615 /// global.  This includes an explicitly requested alignment (if the global
 616 /// has one).
 617 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 618   const Type *ElemType = GV->getType()->getElementType();
 619   unsigned Alignment = getPrefTypeAlignment(ElemType);
 620   if (GV->getAlignment() > Alignment)
 621     Alignment = GV->getAlignment();
 622
 623   if (GV->hasInitializer()) {
 624     if (Alignment < 16) {
 625       // If the global is not external, see if it is large.  If so, give it a
 626       // larger alignment.
 627       if (getTypeSizeInBits(ElemType) > 128)
 628         Alignment = 16;    // 16-byte alignment.
 629     }
 630   }
 631   return Alignment;
 632 }
 633
 634 /// getPreferredAlignmentLog - Return the preferred alignment of the
 635 /// specified global, returned in log form.  This includes an explicitly
 636 /// requested alignment (if the global has one).
 637 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 638   return Log2_32(getPreferredAlignment(GV));
 639 }