lib/IR/DataLayout.cpp

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