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 namespace {
 319
 320 class StructLayoutMap : public AbstractTypeUser {
 321   typedef DenseMap<const StructType*, StructLayout*> LayoutInfoTy;
 322   LayoutInfoTy LayoutInfo;
 323
 324   void RemoveEntry(LayoutInfoTy::iterator I, bool WasAbstract) {
 325     I->second->~StructLayout();
 326     free(I->second);
 327     if (WasAbstract)
 328       I->first->removeAbstractTypeUser(this);
 329     LayoutInfo.erase(I);
 330   }
 331
 332
 333   /// refineAbstractType - The callback method invoked when an abstract type is
 334   /// resolved to another type.  An object must override this method to update
 335   /// its internal state to reference NewType instead of OldType.
 336   ///
 337   virtual void refineAbstractType(const DerivedType *OldTy,
 338                                   const Type *) {
 339     LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(OldTy));
 340     assert(I != LayoutInfo.end() && "Using type but not in map?");
 341     RemoveEntry(I, true);
 342   }
 343
 344   /// typeBecameConcrete - The other case which AbstractTypeUsers must be aware
 345   /// of is when a type makes the transition from being abstract (where it has
 346   /// clients on its AbstractTypeUsers list) to concrete (where it does not).
 347   /// This method notifies ATU's when this occurs for a type.
 348   ///
 349   virtual void typeBecameConcrete(const DerivedType *AbsTy) {
 350     LayoutInfoTy::iterator I = LayoutInfo.find(cast<const StructType>(AbsTy));
 351     assert(I != LayoutInfo.end() && "Using type but not in map?");
 352     RemoveEntry(I, true);
 353   }
 354
 355 public:
 356   virtual ~StructLayoutMap() {
 357     // Remove any layouts.
 358     for (LayoutInfoTy::iterator
 359            I = LayoutInfo.begin(), E = LayoutInfo.end(); I != E; ++I) {
 360       const Type *Key = I->first;
 361       StructLayout *Value = I->second;
 362
 363       if (Key->isAbstract())
 364         Key->removeAbstractTypeUser(this);
 365
 366       Value->~StructLayout();
 367       free(Value);
 368     }
 369   }
 370
 371   void InvalidateEntry(const StructType *Ty) {
 372     LayoutInfoTy::iterator I = LayoutInfo.find(Ty);
 373     if (I == LayoutInfo.end()) return;
 374     RemoveEntry(I, Ty->isAbstract());
 375   }
 376
 377   StructLayout *&operator[](const StructType *STy) {
 378     return LayoutInfo[STy];
 379   }
 380
 381   // for debugging...
 382   virtual void dump() const {}
 383 };
 384
 385 } // end anonymous namespace
 386
 387 TargetData::~TargetData() {
 388   delete static_cast<StructLayoutMap*>(LayoutMap);
 389 }
 390
 391 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 392   if (!LayoutMap)
 393     LayoutMap = new StructLayoutMap();
 394
 395   StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap);
 396   StructLayout *&SL = (*STM)[Ty];
 397   if (SL) return SL;
 398
 399   // Otherwise, create the struct layout.  Because it is variable length, we
 400   // malloc it, then use placement new.
 401   int NumElts = Ty->getNumElements();
 402   StructLayout *L =
 403     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t));
 404
 405   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 406   // entries to be added to TheMap, invalidating our reference.
 407   SL = L;
 408
 409   new (L) StructLayout(Ty, *this);
 410
 411   if (Ty->isAbstract())
 412     Ty->addAbstractTypeUser(STM);
 413
 414   return L;
 415 }
 416
 417 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 418 /// objects.  If a TargetData object is alive when types are being refined and
 419 /// removed, this method must be called whenever a StructType is removed to
 420 /// avoid a dangling pointer in this cache.
 421 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 422   if (!LayoutMap) return;  // No cache.
 423
 424   static_cast<StructLayoutMap*>(LayoutMap)->InvalidateEntry(Ty);
 425 }
 426
 427 std::string TargetData::getStringRepresentation() const {
 428   std::string Result;
 429   raw_string_ostream OS(Result);
 430
 431   OS << (LittleEndian ? "e" : "E")
 432      << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8
 433      << ':' << PointerPrefAlign*8;
 434   for (unsigned i = 0, e = Alignments.size(); i != e; ++i) {
 435     const TargetAlignElem &AI = Alignments[i];
 436     OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':'
 437        << AI.ABIAlign*8 << ':' << AI.PrefAlign*8;
 438   }
 439
 440   if (!LegalIntWidths.empty()) {
 441     OS << "-n" << (unsigned)LegalIntWidths[0];
 442
 443     for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i)
 444       OS << ':' << (unsigned)LegalIntWidths[i];
 445   }
 446   return OS.str();
 447 }
 448
 449
 450 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 451   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 452   switch (Ty->getTypeID()) {
 453   case Type::LabelTyID:
 454   case Type::PointerTyID:
 455     return getPointerSizeInBits();
 456   case Type::ArrayTyID: {
 457     const ArrayType *ATy = cast<ArrayType>(Ty);
 458     return getTypeSizeInBits(ATy->getElementType())*ATy->getNumElements();
 459   }
 460   case Type::StructTyID:
 461     // Get the layout annotation... which is lazily created on demand.
 462     return getStructLayout(cast<StructType>(Ty))->getSizeInBits();
 463   case Type::IntegerTyID:
 464     return cast<IntegerType>(Ty)->getBitWidth();
 465   case Type::VoidTyID:
 466     return 8;
 467   case Type::FloatTyID:
 468     return 32;
 469   case Type::DoubleTyID:
 470     return 64;
 471   case Type::PPC_FP128TyID:
 472   case Type::FP128TyID:
 473     return 128;
 474   // In memory objects this is always aligned to a higher boundary, but
 475   // only 80 bits contain information.
 476   case Type::X86_FP80TyID:
 477     return 80;
 478   case Type::VectorTyID:
 479     return cast<VectorType>(Ty)->getBitWidth();
 480   default:
 481     llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type");
 482     break;
 483   }
 484   return 0;
 485 }
 486
 487 /// getTypeStoreSize - Return the maximum number of bytes that may be
 488 /// overwritten by storing the specified type.  For example, returns 5
 489 /// for i36 and 10 for x86_fp80.
 490 uint64_t TargetData::getTypeStoreSize(const Type *Ty) const {
 491   // Arrays and vectors are allocated as sequences of elements.
 492   if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty)) {
 493     if (ATy->getNumElements() == 0)
 494       return 0;
 495     const Type *ElementType = ATy->getElementType();
 496     return getTypeAllocSize(ElementType) * (ATy->getNumElements() - 1) +
 497            getTypeStoreSize(ElementType);
 498   }
 499   if (const VectorType *VTy = dyn_cast<VectorType>(Ty)) {
 500     const Type *ElementType = VTy->getElementType();
 501     return getTypeAllocSize(ElementType) * (VTy->getNumElements() - 1) +
 502            getTypeStoreSize(ElementType);
 503   }
 504
 505   return (getTypeSizeInBits(Ty)+7)/8;
 506 }
 507
 508 /// getTypeAllocSize - Return the offset in bytes between successive objects
 509 /// of the specified type, including alignment padding.  This is the amount
 510 /// that alloca reserves for this type.  For example, returns 12 or 16 for
 511 /// x86_fp80, depending on alignment.
 512 uint64_t TargetData::getTypeAllocSize(const Type* Ty) const {
 513   // Arrays and vectors are allocated as sequences of elements.
 514   // Note that this means that things like vectors-of-i1 are not bit-packed
 515   // in memory (except on a hypothetical bit-addressable machine). If
 516   // someone builds hardware with native vector-of-i1 stores and the idiom
 517   // of bitcasting vectors to integers in order to bitpack them for storage
 518   // isn't sufficient, TargetData may need new "size" concept.
 519   if (const ArrayType *ATy = dyn_cast<ArrayType>(Ty))
 520     return getTypeAllocSize(ATy->getElementType()) * ATy->getNumElements();
 521   if (const VectorType *VTy = dyn_cast<VectorType>(Ty))
 522     return getTypeAllocSize(VTy->getElementType()) * VTy->getNumElements();
 523
 524   // Round up to the next alignment boundary.
 525   return RoundUpAlignment(getTypeStoreSize(Ty), getABITypeAlignment(Ty));
 526 }
 527
 528 /*!
 529   \param abi_or_pref Flag that determines which alignment is returned. true
 530   returns the ABI alignment, false returns the preferred alignment.
 531   \param Ty The underlying type for which alignment is determined.
 532
 533   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 534   == false) for the requested type \a Ty.
 535  */
 536 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const {
 537   int AlignType = -1;
 538
 539   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 540   switch (Ty->getTypeID()) {
 541   // Early escape for the non-numeric types.
 542   case Type::LabelTyID:
 543   case Type::PointerTyID:
 544     return (abi_or_pref
 545             ? getPointerABIAlignment()
 546             : getPointerPrefAlignment());
 547   case Type::ArrayTyID:
 548     return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref);
 549
 550   case Type::StructTyID: {
 551     // Packed structure types always have an ABI alignment of one.
 552     if (cast<StructType>(Ty)->isPacked() && abi_or_pref)
 553       return 1;
 554
 555     // Get the layout annotation... which is lazily created on demand.
 556     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 557     unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty);
 558     return std::max(Align, (unsigned)Layout->getAlignment());
 559   }
 560   case Type::IntegerTyID:
 561   case Type::VoidTyID:
 562     AlignType = INTEGER_ALIGN;
 563     break;
 564   case Type::FloatTyID:
 565   case Type::DoubleTyID:
 566   // PPC_FP128TyID and FP128TyID have different data contents, but the
 567   // same size and alignment, so they look the same here.
 568   case Type::PPC_FP128TyID:
 569   case Type::FP128TyID:
 570   case Type::X86_FP80TyID:
 571     AlignType = FLOAT_ALIGN;
 572     break;
 573   case Type::VectorTyID:
 574     AlignType = VECTOR_ALIGN;
 575     break;
 576   default:
 577     llvm_unreachable("Bad type for getAlignment!!!");
 578     break;
 579   }
 580
 581   return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty),
 582                           abi_or_pref, Ty);
 583 }
 584
 585 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 586   return getAlignment(Ty, true);
 587 }
 588
 589 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for
 590 /// an integer type of the specified bitwidth.
 591 unsigned char TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const {
 592   return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0);
 593 }
 594
 595
 596 unsigned char TargetData::getCallFrameTypeAlignment(const Type *Ty) const {
 597   for (unsigned i = 0, e = Alignments.size(); i != e; ++i)
 598     if (Alignments[i].AlignType == STACK_ALIGN)
 599       return Alignments[i].ABIAlign;
 600
 601   return getABITypeAlignment(Ty);
 602 }
 603
 604 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 605   return getAlignment(Ty, false);
 606 }
 607
 608 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 609   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 610   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 611   return Log2_32(Align);
 612 }
 613
 614 /// getIntPtrType - Return an unsigned integer type that is the same size or
 615 /// greater to the host pointer size.
 616 const IntegerType *TargetData::getIntPtrType(LLVMContext &C) const {
 617   return IntegerType::get(C, getPointerSizeInBits());
 618 }
 619
 620
 621 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 622                                       unsigned NumIndices) const {
 623   const Type *Ty = ptrTy;
 624   assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()");
 625   uint64_t Result = 0;
 626
 627   generic_gep_type_iterator<Value* const*>
 628     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 629   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 630     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 631       assert(Indices[CurIDX]->getType() ==
 632              Type::getInt32Ty(ptrTy->getContext()) &&
 633              "Illegal struct idx");
 634       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 635
 636       // Get structure layout information...
 637       const StructLayout *Layout = getStructLayout(STy);
 638
 639       // Add in the offset, as calculated by the structure layout info...
 640       Result += Layout->getElementOffset(FieldNo);
 641
 642       // Update Ty to refer to current element
 643       Ty = STy->getElementType(FieldNo);
 644     } else {
 645       // Update Ty to refer to current element
 646       Ty = cast<SequentialType>(Ty)->getElementType();
 647
 648       // Get the array index and the size of each array element.
 649       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 650       Result += arrayIdx * (int64_t)getTypeAllocSize(Ty);
 651     }
 652   }
 653
 654   return Result;
 655 }
 656
 657 /// getPreferredAlignment - Return the preferred alignment of the specified
 658 /// global.  This includes an explicitly requested alignment (if the global
 659 /// has one).
 660 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const {
 661   const Type *ElemType = GV->getType()->getElementType();
 662   unsigned Alignment = getPrefTypeAlignment(ElemType);
 663   if (GV->getAlignment() > Alignment)
 664     Alignment = GV->getAlignment();
 665
 666   if (GV->hasInitializer()) {
 667     if (Alignment < 16) {
 668       // If the global is not external, see if it is large.  If so, give it a
 669       // larger alignment.
 670       if (getTypeSizeInBits(ElemType) > 128)
 671         Alignment = 16;    // 16-byte alignment.
 672     }
 673   }
 674   return Alignment;
 675 }
 676
 677 /// getPreferredAlignmentLog - Return the preferred alignment of the
 678 /// specified global, returned in log form.  This includes an explicitly
 679 /// requested alignment (if the global has one).
 680 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 681   return Log2_32(getPreferredAlignment(GV));
 682 }