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