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