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