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
  39 //===----------------------------------------------------------------------===//
  40 // Support for StructLayout
  41 //===----------------------------------------------------------------------===//
  42
  43 StructLayout::StructLayout(const StructType *ST, const TargetData &TD) {
  44   StructAlignment = 0;
  45   StructSize = 0;
  46   NumElements = ST->getNumElements();
  47
  48   // Loop over each of the elements, placing them in memory...
  49   for (unsigned i = 0, e = NumElements; i != e; ++i) {
  50     const Type *Ty = ST->getElementType(i);
  51     unsigned TyAlign;
  52     uint64_t TySize;
  53     TyAlign = (ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty));
  54     TySize = TD.getTypeSize(Ty);
  55
  56     // Add padding if necessary to make the data element aligned properly...
  57     if (StructSize % TyAlign != 0)
  58       StructSize = (StructSize/TyAlign + 1) * TyAlign;   // Add padding...
  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   return SI-&MemberOffsets[0];
  89 }
  90
  91 //===----------------------------------------------------------------------===//
  92 // TargetAlignElem, TargetAlign support
  93 //===----------------------------------------------------------------------===//
  94
  95 TargetAlignElem
  96 TargetAlignElem::get(AlignTypeEnum align_type, unsigned char abi_align,
  97                      unsigned char pref_align, short bit_width) {
  98   TargetAlignElem retval;
  99   retval.AlignType = align_type;
 100   retval.ABIAlign = abi_align;
 101   retval.PrefAlign = pref_align;
 102   retval.TypeBitWidth = bit_width;
 103   return retval;
 104 }
 105
 106 bool
 107 TargetAlignElem::operator<(const TargetAlignElem &rhs) const {
 108   return ((AlignType < rhs.AlignType)
 109           || (AlignType == rhs.AlignType && TypeBitWidth < rhs.TypeBitWidth));
 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:<size>:<abi_align>:<pref_align></i>: Pointer size, ABI and preferred
 155  alignment.
 156  <br><br>
 157  <i><type><size>:<abi_align>:<pref_align></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(PACKED_ALIGN,    8,  8, 64);  // v2i32
 188   setAlignment(PACKED_ALIGN,   16, 16, 128); // v16i8, v8i16, v4i32, ...
 189   setAlignment(AGGREGATE_ALIGN, 0,  0,  0);  // struct, union, class, ...
 190
 191   while (!temp.empty()) {
 192     std::string token = getToken(temp, "-");
 193
 194     std::string arg0 = getToken(token, ":");
 195     const char *p = arg0.c_str();
 196     AlignTypeEnum align_type;
 197     short size;
 198     unsigned char abi_align;
 199     unsigned char pref_align;
 200
 201     switch(*p) {
 202     case 'E':
 203       LittleEndian = false;
 204       break;
 205     case 'e':
 206       LittleEndian = true;
 207       break;
 208     case 'p':
 209       PointerMemSize = atoi(getToken(token,":").c_str()) / 8;
 210       PointerABIAlign = atoi(getToken(token,":").c_str()) / 8;
 211       PointerPrefAlign = atoi(getToken(token,":").c_str()) / 8;
 212       if (PointerPrefAlign == 0)
 213         PointerPrefAlign = PointerABIAlign;
 214       break;
 215     case 'i':
 216     case 'v':
 217     case 'f':
 218     case 'a': {
 219       align_type = (*p == 'i' ? INTEGER_ALIGN :
 220                     (*p == 'f' ? FLOAT_ALIGN :
 221                      (*p == 'v' ? PACKED_ALIGN : AGGREGATE_ALIGN)));
 222       size = (short) atoi(++p);
 223       abi_align = atoi(getToken(token, ":").c_str()) / 8;
 224       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   init(M->getDataLayout());
 238 }
 239
 240 void
 241 TargetData::setAlignment(AlignTypeEnum align_type, unsigned char abi_align,
 242                          unsigned char pref_align, short bit_width) {
 243   TargetAlignElem elt = TargetAlignElem::get(align_type, abi_align,
 244                                              pref_align, bit_width);
 245   std::pair<align_iterator, align_iterator> ins_result =
 246             std::equal_range(Alignments.begin(), Alignments.end(), elt);
 247   align_iterator I = ins_result.first;
 248   if (I->AlignType == align_type && I->TypeBitWidth == bit_width) {
 249     // Update the abi, preferred alignments.
 250     I->ABIAlign = abi_align;
 251     I->PrefAlign = pref_align;
 252   } else
 253     Alignments.insert(I, elt);
 254
 255 #if 0
 256   // Keep around for debugging and testing...
 257   align_iterator E = ins_result.second;
 258
 259   cerr << "setAlignment(" << elt << ")\n";
 260   cerr << "I = " << (I - Alignments.begin())
 261        << ", E = " << (E - Alignments.begin()) << "\n";
 262   std::copy(Alignments.begin(), Alignments.end(),
 263             std::ostream_iterator<TargetAlignElem>(*cerr, "\n"));
 264   cerr << "=====\n";
 265 #endif
 266 }
 267
 268 const TargetAlignElem &
 269 TargetData::getAlignment(AlignTypeEnum align_type, short bit_width) const
 270 {
 271   std::pair<align_const_iterator, align_const_iterator> find_result =
 272                 std::equal_range(Alignments.begin(), Alignments.end(),
 273                                  TargetAlignElem::get(align_type, 0, 0,
 274                                                       bit_width));
 275   align_const_iterator I = find_result.first;
 276
 277   // Note: This may not be reasonable if variable-width integer sizes are
 278   // passed, at which point, more sophisticated searching will need to be done.
 279   return *I;
 280 }
 281
 282 /// LayoutInfo - The lazy cache of structure layout information maintained by
 283 /// TargetData.  Note that the struct types must have been free'd before
 284 /// llvm_shutdown is called (and thus this is deallocated) because all the
 285 /// targets with cached elements should have been destroyed.
 286 ///
 287 typedef std::pair<const TargetData*,const StructType*> LayoutKey;
 288
 289 struct DenseMapLayoutKeyInfo {
 290   static inline LayoutKey getEmptyKey() { return LayoutKey(0, 0); }
 291   static inline LayoutKey getTombstoneKey() {
 292     return LayoutKey((TargetData*)(intptr_t)-1, 0);
 293   }
 294   static unsigned getHashValue(const LayoutKey &Val) {
 295     return DenseMapKeyInfo<void*>::getHashValue(Val.first) ^
 296            DenseMapKeyInfo<void*>::getHashValue(Val.second);
 297   }
 298   static bool isPod() { return true; }
 299 };
 300
 301 typedef DenseMap<LayoutKey, StructLayout*, DenseMapLayoutKeyInfo> LayoutInfoTy;
 302 static ManagedStatic<LayoutInfoTy> LayoutInfo;
 303
 304
 305 TargetData::~TargetData() {
 306   if (LayoutInfo.isConstructed()) {
 307     // Remove any layouts for this TD.
 308     LayoutInfoTy &TheMap = *LayoutInfo;
 309     for (LayoutInfoTy::iterator I = TheMap.begin(), E = TheMap.end();
 310          I != E; ) {
 311       if (I->first.first == this) {
 312         I->second->~StructLayout();
 313         free(I->second);
 314         TheMap.erase(I++);
 315       } else {
 316         ++I;
 317       }
 318     }
 319   }
 320 }
 321
 322 const StructLayout *TargetData::getStructLayout(const StructType *Ty) const {
 323   LayoutInfoTy &TheMap = *LayoutInfo;
 324
 325   StructLayout *&SL = TheMap[LayoutKey(this, Ty)];
 326   if (SL) return SL;
 327
 328   // Otherwise, create the struct layout.  Because it is variable length, we
 329   // malloc it, then use placement new.
 330   unsigned NumElts = Ty->getNumElements();
 331   StructLayout *L =
 332     (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1)*sizeof(uint64_t));
 333
 334   // Set SL before calling StructLayout's ctor.  The ctor could cause other
 335   // entries to be added to TheMap, invalidating our reference.
 336   SL = L;
 337
 338   new (L) StructLayout(Ty, *this);
 339
 340   return L;
 341 }
 342
 343 /// InvalidateStructLayoutInfo - TargetData speculatively caches StructLayout
 344 /// objects.  If a TargetData object is alive when types are being refined and
 345 /// removed, this method must be called whenever a StructType is removed to
 346 /// avoid a dangling pointer in this cache.
 347 void TargetData::InvalidateStructLayoutInfo(const StructType *Ty) const {
 348   if (!LayoutInfo.isConstructed()) return;  // No cache.
 349
 350   LayoutInfoTy::iterator I = LayoutInfo->find(LayoutKey(this, Ty));
 351   if (I != LayoutInfo->end()) {
 352     I->second->~StructLayout();
 353     free(I->second);
 354     LayoutInfo->erase(I);
 355   }
 356 }
 357
 358
 359 std::string TargetData::getStringRepresentation() const {
 360   std::string repr;
 361   repr.append(LittleEndian ? "e" : "E");
 362   repr.append("-p:").append(itostr((int64_t) (PointerMemSize * 8))).
 363       append(":").append(itostr((int64_t) (PointerABIAlign * 8))).
 364       append(":").append(itostr((int64_t) (PointerPrefAlign * 8)));
 365   for (align_const_iterator I = Alignments.begin();
 366        I != Alignments.end();
 367        ++I) {
 368     repr.append("-").append(1, (char) I->AlignType).
 369       append(utostr((int64_t) I->TypeBitWidth)).
 370       append(":").append(utostr((uint64_t) (I->ABIAlign * 8))).
 371       append(":").append(utostr((uint64_t) (I->PrefAlign * 8)));
 372   }
 373   return repr;
 374 }
 375
 376
 377 uint64_t TargetData::getTypeSize(const Type *Ty) const {
 378   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 379   switch (Ty->getTypeID()) {
 380   case Type::LabelTyID:
 381   case Type::PointerTyID:
 382     return getPointerSize();
 383   case Type::ArrayTyID: {
 384     const ArrayType *ATy = cast<ArrayType>(Ty);
 385     uint64_t Size;
 386     unsigned char Alignment;
 387     Size = getTypeSize(ATy->getElementType());
 388     Alignment = getABITypeAlignment(ATy->getElementType());
 389     unsigned AlignedSize = (Size + Alignment - 1)/Alignment*Alignment;
 390     return AlignedSize*ATy->getNumElements();
 391   }
 392   case Type::StructTyID: {
 393     // Get the layout annotation... which is lazily created on demand.
 394     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 395     return Layout->getSizeInBytes();
 396   }
 397   case Type::IntegerTyID: {
 398     unsigned BitWidth = cast<IntegerType>(Ty)->getBitWidth();
 399     if (BitWidth <= 8) {
 400       return 1;
 401     } else if (BitWidth <= 16) {
 402       return 2;
 403     } else if (BitWidth <= 32) {
 404       return 4;
 405     } else if (BitWidth <= 64) {
 406       return 8;
 407     } else
 408       assert(0 && "Integer types > 64 bits not supported.");
 409     break;
 410   }
 411   case Type::VoidTyID:
 412     return 1;
 413   case Type::FloatTyID:
 414     return 4;
 415   case Type::DoubleTyID:
 416     return 8;
 417   case Type::PackedTyID: {
 418     const PackedType *PTy = cast<PackedType>(Ty);
 419     return PTy->getBitWidth() / 8;
 420   }
 421   default:
 422     assert(0 && "TargetData::getTypeSize(): Unsupported type");
 423     break;
 424   }
 425   return 0;
 426 }
 427
 428 uint64_t TargetData::getTypeSizeInBits(const Type *Ty) const {
 429   if (Ty->isInteger())
 430     return cast<IntegerType>(Ty)->getBitWidth();
 431   else
 432     return getTypeSize(Ty) * 8;
 433 }
 434
 435
 436 /*!
 437   \param abi_or_pref Flag that determines which alignment is returned. true
 438   returns the ABI alignment, false returns the preferred alignment.
 439   \param Ty The underlying type for which alignment is determined.
 440
 441   Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref
 442   == false) for the requested type \a Ty.
 443  */
 444 unsigned char TargetData::getAlignment(const Type *Ty, bool abi_or_pref) const
 445 {
 446   int AlignType = -1;
 447
 448   assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!");
 449   switch (Ty->getTypeID()) {
 450   /* Early escape for the non-numeric types */
 451   case Type::LabelTyID:
 452   case Type::PointerTyID:
 453     return (abi_or_pref
 454             ? getPointerABIAlignment()
 455             : getPointerPrefAlignment());
 456   case Type::ArrayTyID: {
 457     const ArrayType *ATy = cast<ArrayType>(Ty);
 458     return (abi_or_pref
 459             ? getABITypeAlignment(ATy->getElementType())
 460             : getPrefTypeAlignment(ATy->getElementType()));
 461   }
 462   case Type::StructTyID: {
 463       // Get the layout annotation... which is lazily created on demand.
 464     const StructLayout *Layout = getStructLayout(cast<StructType>(Ty));
 465     const TargetAlignElem &elem = getAlignment(AGGREGATE_ALIGN, 0);
 466     assert(validAlignment(elem)
 467            && "Aggregate alignment return invalid in getAlignment");
 468     if (abi_or_pref) {
 469       return (elem.ABIAlign < Layout->getAlignment()
 470               ? Layout->StructAlignment
 471               : elem.ABIAlign);
 472     } else {
 473       return (elem.PrefAlign < Layout->getAlignment()
 474               ? Layout->StructAlignment
 475               : elem.PrefAlign);
 476     }
 477   }
 478   case Type::IntegerTyID:
 479   case Type::VoidTyID:
 480     AlignType = INTEGER_ALIGN;
 481     break;
 482   case Type::FloatTyID:
 483   case Type::DoubleTyID:
 484     AlignType = FLOAT_ALIGN;
 485     break;
 486   case Type::PackedTyID:
 487     AlignType = PACKED_ALIGN;
 488     break;
 489   default:
 490     assert(0 && "Bad type for getAlignment!!!");
 491     break;
 492   }
 493
 494   const TargetAlignElem &elem = getAlignment((AlignTypeEnum) AlignType,
 495                                              getTypeSize(Ty) * 8);
 496   if (validAlignment(elem))
 497     return (abi_or_pref ? elem.ABIAlign : elem.PrefAlign);
 498   else {
 499     cerr << "TargetData::getAlignment: align type " << AlignType
 500          << " size " << getTypeSize(Ty) << " not found in Alignments.\n";
 501     abort();
 502     /*NOTREACHED*/
 503     return 0;
 504   }
 505 }
 506
 507 unsigned char TargetData::getABITypeAlignment(const Type *Ty) const {
 508   return getAlignment(Ty, true);
 509 }
 510
 511 unsigned char TargetData::getPrefTypeAlignment(const Type *Ty) const {
 512   return getAlignment(Ty, false);
 513 }
 514
 515 unsigned char TargetData::getPreferredTypeAlignmentShift(const Type *Ty) const {
 516   unsigned Align = (unsigned) getPrefTypeAlignment(Ty);
 517   assert(!(Align & (Align-1)) && "Alignment is not a power of two!");
 518   return Log2_32(Align);
 519 }
 520
 521 /// getIntPtrType - Return an unsigned integer type that is the same size or
 522 /// greater to the host pointer size.
 523 const Type *TargetData::getIntPtrType() const {
 524   switch (getPointerSize()) {
 525   default: assert(0 && "Unknown pointer size!");
 526   case 2: return Type::Int16Ty;
 527   case 4: return Type::Int32Ty;
 528   case 8: return Type::Int64Ty;
 529   }
 530 }
 531
 532
 533 uint64_t TargetData::getIndexedOffset(const Type *ptrTy, Value* const* Indices,
 534                                       unsigned NumIndices) const {
 535   const Type *Ty = ptrTy;
 536   assert(isa<PointerType>(Ty) && "Illegal argument for getIndexedOffset()");
 537   uint64_t Result = 0;
 538
 539   generic_gep_type_iterator<Value* const*>
 540     TI = gep_type_begin(ptrTy, Indices, Indices+NumIndices);
 541   for (unsigned CurIDX = 0; CurIDX != NumIndices; ++CurIDX, ++TI) {
 542     if (const StructType *STy = dyn_cast<StructType>(*TI)) {
 543       assert(Indices[CurIDX]->getType() == Type::Int32Ty &&"Illegal struct idx");
 544       unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue();
 545
 546       // Get structure layout information...
 547       const StructLayout *Layout = getStructLayout(STy);
 548
 549       // Add in the offset, as calculated by the structure layout info...
 550       Result += Layout->getElementOffset(FieldNo);
 551
 552       // Update Ty to refer to current element
 553       Ty = STy->getElementType(FieldNo);
 554     } else {
 555       // Update Ty to refer to current element
 556       Ty = cast<SequentialType>(Ty)->getElementType();
 557
 558       // Get the array index and the size of each array element.
 559       int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue();
 560       Result += arrayIdx * (int64_t)getTypeSize(Ty);
 561     }
 562   }
 563
 564   return Result;
 565 }
 566
 567 /// getPreferredAlignmentLog - Return the preferred alignment of the
 568 /// specified global, returned in log form.  This includes an explicitly
 569 /// requested alignment (if the global has one).
 570 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const {
 571   const Type *ElemType = GV->getType()->getElementType();
 572   unsigned Alignment = getPreferredTypeAlignmentShift(ElemType);
 573   if (GV->getAlignment() > (1U << Alignment))
 574     Alignment = Log2_32(GV->getAlignment());
 575
 576   if (GV->hasInitializer()) {
 577     if (Alignment < 4) {
 578       // If the global is not external, see if it is large.  If so, give it a
 579       // larger alignment.
 580       if (getTypeSize(ElemType) > 128)
 581         Alignment = 4;    // 16-byte alignment.
 582     }
 583   }
 584   return Alignment;
 585 }