lib/Target/TargetData.cpp

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