lib/Target/TargetData.cpp

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