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