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/Support/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 INITIALIZE_PASS(TargetData, "targetdata", "Target Data Layout", false, true) 38 char TargetData::ID = 0; 39 40 //===----------------------------------------------------------------------===// 41 // Support for StructLayout 42 //===----------------------------------------------------------------------===// 43 44 StructLayout::StructLayout(StructType *ST, const TargetData &TD) { 45 assert(!ST->isOpaque() && "Cannot get layout of opaque structs"); 46 StructAlignment = 0; 47 StructSize = 0; 48 NumElements = ST->getNumElements(); 49 50 // Loop over each of the elements, placing them in memory. 51 for (unsigned i = 0, e = NumElements; i != e; ++i) { 52 Type *Ty = ST->getElementType(i); 53 unsigned TyAlign = ST->isPacked() ? 1 : TD.getABITypeAlignment(Ty); 54 55 // Add padding if necessary to align the data element properly. 56 if ((StructSize & (TyAlign-1)) != 0) 57 StructSize = 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 abi_align, 102 unsigned 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 int getInt(StringRef R) { 129 int Result = 0; 130 R.getAsInteger(10, Result); 131 return Result; 132 } 133 134 void TargetData::init() { 135 initializeTargetDataPass(*PassRegistry::getPassRegistry()); 136 137 LayoutMap = 0; 138 LittleEndian = false; 139 PointerMemSize = 8; 140 PointerABIAlign = 8; 141 PointerPrefAlign = PointerABIAlign; 142 StackNaturalAlign = 0; 143 144 // Default alignments 145 setAlignment(INTEGER_ALIGN, 1, 1, 1); // i1 146 setAlignment(INTEGER_ALIGN, 1, 1, 8); // i8 147 setAlignment(INTEGER_ALIGN, 2, 2, 16); // i16 148 setAlignment(INTEGER_ALIGN, 4, 4, 32); // i32 149 setAlignment(INTEGER_ALIGN, 4, 8, 64); // i64 150 setAlignment(FLOAT_ALIGN, 2, 2, 16); // half 151 setAlignment(FLOAT_ALIGN, 4, 4, 32); // float 152 setAlignment(FLOAT_ALIGN, 8, 8, 64); // double 153 setAlignment(FLOAT_ALIGN, 16, 16, 128); // ppcf128, quad, ... 154 setAlignment(VECTOR_ALIGN, 8, 8, 64); // v2i32, v1i64, ... 155 setAlignment(VECTOR_ALIGN, 16, 16, 128); // v16i8, v8i16, v4i32, ... 156 setAlignment(AGGREGATE_ALIGN, 0, 8, 0); // struct 157 } 158 159 std::string TargetData::parseSpecifier(StringRef Desc, TargetData *td) { 160 161 if (td) 162 td->init(); 163 164 while (!Desc.empty()) { 165 std::pair<StringRef, StringRef> Split = Desc.split('-'); 166 StringRef Token = Split.first; 167 Desc = Split.second; 168 169 if (Token.empty()) 170 continue; 171 172 Split = Token.split(':'); 173 StringRef Specifier = Split.first; 174 Token = Split.second; 175 176 assert(!Specifier.empty() && "Can't be empty here"); 177 178 switch (Specifier[0]) { 179 case 'E': 180 if (td) 181 td->LittleEndian = false; 182 break; 183 case 'e': 184 if (td) 185 td->LittleEndian = true; 186 break; 187 case 'p': { 188 // Pointer size. 189 Split = Token.split(':'); 190 int PointerMemSizeBits = getInt(Split.first); 191 if (PointerMemSizeBits < 0 || PointerMemSizeBits % 8 != 0) 192 return "invalid pointer size, must be a positive 8-bit multiple"; 193 if (td) 194 td->PointerMemSize = PointerMemSizeBits / 8; 195 196 // Pointer ABI alignment. 197 Split = Split.second.split(':'); 198 int PointerABIAlignBits = getInt(Split.first); 199 if (PointerABIAlignBits < 0 || PointerABIAlignBits % 8 != 0) { 200 return "invalid pointer ABI alignment, " 201 "must be a positive 8-bit multiple"; 202 } 203 if (td) 204 td->PointerABIAlign = PointerABIAlignBits / 8; 205 206 // Pointer preferred alignment. 207 Split = Split.second.split(':'); 208 int PointerPrefAlignBits = getInt(Split.first); 209 if (PointerPrefAlignBits < 0 || PointerPrefAlignBits % 8 != 0) { 210 return "invalid pointer preferred alignment, " 211 "must be a positive 8-bit multiple"; 212 } 213 if (td) { 214 td->PointerPrefAlign = PointerPrefAlignBits / 8; 215 if (td->PointerPrefAlign == 0) 216 td->PointerPrefAlign = td->PointerABIAlign; 217 } 218 break; 219 } 220 case 'i': 221 case 'v': 222 case 'f': 223 case 'a': 224 case 's': { 225 AlignTypeEnum AlignType; 226 char field = Specifier[0]; 227 switch (field) { 228 default: 229 case 'i': AlignType = INTEGER_ALIGN; break; 230 case 'v': AlignType = VECTOR_ALIGN; break; 231 case 'f': AlignType = FLOAT_ALIGN; break; 232 case 'a': AlignType = AGGREGATE_ALIGN; break; 233 case 's': AlignType = STACK_ALIGN; break; 234 } 235 int Size = getInt(Specifier.substr(1)); 236 if (Size < 0) { 237 return std::string("invalid ") + field + "-size field, " 238 "must be positive"; 239 } 240 241 Split = Token.split(':'); 242 int ABIAlignBits = getInt(Split.first); 243 if (ABIAlignBits < 0 || ABIAlignBits % 8 != 0) { 244 return std::string("invalid ") + field +"-abi-alignment field, " 245 "must be a positive 8-bit multiple"; 246 } 247 unsigned ABIAlign = ABIAlignBits / 8; 248 249 Split = Split.second.split(':'); 250 251 int PrefAlignBits = getInt(Split.first); 252 if (PrefAlignBits < 0 || PrefAlignBits % 8 != 0) { 253 return std::string("invalid ") + field +"-preferred-alignment field, " 254 "must be a positive 8-bit multiple"; 255 } 256 unsigned PrefAlign = PrefAlignBits / 8; 257 if (PrefAlign == 0) 258 PrefAlign = ABIAlign; 259 260 if (td) 261 td->setAlignment(AlignType, ABIAlign, PrefAlign, Size); 262 break; 263 } 264 case 'n': // Native integer types. 265 Specifier = Specifier.substr(1); 266 do { 267 int Width = getInt(Specifier); 268 if (Width <= 0) { 269 return std::string("invalid native integer size \'") + Specifier.str() + 270 "\', must be a positive integer."; 271 } 272 if (td && Width != 0) 273 td->LegalIntWidths.push_back(Width); 274 Split = Token.split(':'); 275 Specifier = Split.first; 276 Token = Split.second; 277 } while (!Specifier.empty() || !Token.empty()); 278 break; 279 case 'S': { // Stack natural alignment. 280 int StackNaturalAlignBits = getInt(Specifier.substr(1)); 281 if (StackNaturalAlignBits < 0 || StackNaturalAlignBits % 8 != 0) { 282 return "invalid natural stack alignment (S-field), " 283 "must be a positive 8-bit multiple"; 284 } 285 if (td) 286 td->StackNaturalAlign = StackNaturalAlignBits / 8; 287 break; 288 } 289 default: 290 break; 291 } 292 } 293 294 return ""; 295 } 296 297 /// Default ctor. 298 /// 299 /// @note This has to exist, because this is a pass, but it should never be 300 /// used. 301 TargetData::TargetData() : ImmutablePass(ID) { 302 report_fatal_error("Bad TargetData ctor used. " 303 "Tool did not specify a TargetData to use?"); 304 } 305 306 TargetData::TargetData(const Module *M) 307 : ImmutablePass(ID) { 308 std::string errMsg = parseSpecifier(M->getDataLayout(), this); 309 assert(errMsg == "" && "Module M has malformed target data layout string."); 310 (void)errMsg; 311 } 312 313 void 314 TargetData::setAlignment(AlignTypeEnum align_type, unsigned abi_align, 315 unsigned pref_align, uint32_t bit_width) { 316 assert(abi_align <= pref_align && "Preferred alignment worse than ABI!"); 317 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 318 if (Alignments[i].AlignType == align_type && 319 Alignments[i].TypeBitWidth == bit_width) { 320 // Update the abi, preferred alignments. 321 Alignments[i].ABIAlign = abi_align; 322 Alignments[i].PrefAlign = pref_align; 323 return; 324 } 325 } 326 327 Alignments.push_back(TargetAlignElem::get(align_type, abi_align, 328 pref_align, bit_width)); 329 } 330 331 /// getAlignmentInfo - Return the alignment (either ABI if ABIInfo = true or 332 /// preferred if ABIInfo = false) the target wants for the specified datatype. 333 unsigned TargetData::getAlignmentInfo(AlignTypeEnum AlignType, 334 uint32_t BitWidth, bool ABIInfo, 335 Type *Ty) const { 336 // Check to see if we have an exact match and remember the best match we see. 337 int BestMatchIdx = -1; 338 int LargestInt = -1; 339 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 340 if (Alignments[i].AlignType == AlignType && 341 Alignments[i].TypeBitWidth == BitWidth) 342 return ABIInfo ? Alignments[i].ABIAlign : Alignments[i].PrefAlign; 343 344 // The best match so far depends on what we're looking for. 345 if (AlignType == INTEGER_ALIGN && 346 Alignments[i].AlignType == INTEGER_ALIGN) { 347 // The "best match" for integers is the smallest size that is larger than 348 // the BitWidth requested. 349 if (Alignments[i].TypeBitWidth > BitWidth && (BestMatchIdx == -1 || 350 Alignments[i].TypeBitWidth < Alignments[BestMatchIdx].TypeBitWidth)) 351 BestMatchIdx = i; 352 // However, if there isn't one that's larger, then we must use the 353 // largest one we have (see below) 354 if (LargestInt == -1 || 355 Alignments[i].TypeBitWidth > Alignments[LargestInt].TypeBitWidth) 356 LargestInt = i; 357 } 358 } 359 360 // Okay, we didn't find an exact solution. Fall back here depending on what 361 // is being looked for. 362 if (BestMatchIdx == -1) { 363 // If we didn't find an integer alignment, fall back on most conservative. 364 if (AlignType == INTEGER_ALIGN) { 365 BestMatchIdx = LargestInt; 366 } else { 367 assert(AlignType == VECTOR_ALIGN && "Unknown alignment type!"); 368 369 // By default, use natural alignment for vector types. This is consistent 370 // with what clang and llvm-gcc do. 371 unsigned Align = getTypeAllocSize(cast<VectorType>(Ty)->getElementType()); 372 Align *= cast<VectorType>(Ty)->getNumElements(); 373 // If the alignment is not a power of 2, round up to the next power of 2. 374 // This happens for non-power-of-2 length vectors. 375 if (Align & (Align-1)) 376 Align = NextPowerOf2(Align); 377 return Align; 378 } 379 } 380 381 // Since we got a "best match" index, just return it. 382 return ABIInfo ? Alignments[BestMatchIdx].ABIAlign 383 : Alignments[BestMatchIdx].PrefAlign; 384 } 385 386 namespace { 387 388 class StructLayoutMap { 389 typedef DenseMap<StructType*, StructLayout*> LayoutInfoTy; 390 LayoutInfoTy LayoutInfo; 391 392 public: 393 virtual ~StructLayoutMap() { 394 // Remove any layouts. 395 for (LayoutInfoTy::iterator I = LayoutInfo.begin(), E = LayoutInfo.end(); 396 I != E; ++I) { 397 StructLayout *Value = I->second; 398 Value->~StructLayout(); 399 free(Value); 400 } 401 } 402 403 StructLayout *&operator[](StructType *STy) { 404 return LayoutInfo[STy]; 405 } 406 407 // for debugging... 408 virtual void dump() const {} 409 }; 410 411 } // end anonymous namespace 412 413 TargetData::~TargetData() { 414 delete static_cast<StructLayoutMap*>(LayoutMap); 415 } 416 417 const StructLayout *TargetData::getStructLayout(StructType *Ty) const { 418 if (!LayoutMap) 419 LayoutMap = new StructLayoutMap(); 420 421 StructLayoutMap *STM = static_cast<StructLayoutMap*>(LayoutMap); 422 StructLayout *&SL = (*STM)[Ty]; 423 if (SL) return SL; 424 425 // Otherwise, create the struct layout. Because it is variable length, we 426 // malloc it, then use placement new. 427 int NumElts = Ty->getNumElements(); 428 StructLayout *L = 429 (StructLayout *)malloc(sizeof(StructLayout)+(NumElts-1) * sizeof(uint64_t)); 430 431 // Set SL before calling StructLayout's ctor. The ctor could cause other 432 // entries to be added to TheMap, invalidating our reference. 433 SL = L; 434 435 new (L) StructLayout(Ty, *this); 436 437 return L; 438 } 439 440 std::string TargetData::getStringRepresentation() const { 441 std::string Result; 442 raw_string_ostream OS(Result); 443 444 OS << (LittleEndian ? "e" : "E") 445 << "-p:" << PointerMemSize*8 << ':' << PointerABIAlign*8 446 << ':' << PointerPrefAlign*8 447 << "-S" << StackNaturalAlign*8; 448 449 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) { 450 const TargetAlignElem &AI = Alignments[i]; 451 OS << '-' << (char)AI.AlignType << AI.TypeBitWidth << ':' 452 << AI.ABIAlign*8 << ':' << AI.PrefAlign*8; 453 } 454 455 if (!LegalIntWidths.empty()) { 456 OS << "-n" << (unsigned)LegalIntWidths[0]; 457 458 for (unsigned i = 1, e = LegalIntWidths.size(); i != e; ++i) 459 OS << ':' << (unsigned)LegalIntWidths[i]; 460 } 461 return OS.str(); 462 } 463 464 465 uint64_t TargetData::getTypeSizeInBits(Type *Ty) const { 466 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 467 switch (Ty->getTypeID()) { 468 case Type::LabelTyID: 469 case Type::PointerTyID: 470 return getPointerSizeInBits(); 471 case Type::ArrayTyID: { 472 ArrayType *ATy = cast<ArrayType>(Ty); 473 return getTypeAllocSizeInBits(ATy->getElementType())*ATy->getNumElements(); 474 } 475 case Type::StructTyID: 476 // Get the layout annotation... which is lazily created on demand. 477 return getStructLayout(cast<StructType>(Ty))->getSizeInBits(); 478 case Type::IntegerTyID: 479 return cast<IntegerType>(Ty)->getBitWidth(); 480 case Type::VoidTyID: 481 return 8; 482 case Type::HalfTyID: 483 return 16; 484 case Type::FloatTyID: 485 return 32; 486 case Type::DoubleTyID: 487 case Type::X86_MMXTyID: 488 return 64; 489 case Type::PPC_FP128TyID: 490 case Type::FP128TyID: 491 return 128; 492 // In memory objects this is always aligned to a higher boundary, but 493 // only 80 bits contain information. 494 case Type::X86_FP80TyID: 495 return 80; 496 case Type::VectorTyID: 497 return cast<VectorType>(Ty)->getBitWidth(); 498 default: 499 llvm_unreachable("TargetData::getTypeSizeInBits(): Unsupported type"); 500 } 501 } 502 503 /*! 504 \param abi_or_pref Flag that determines which alignment is returned. true 505 returns the ABI alignment, false returns the preferred alignment. 506 \param Ty The underlying type for which alignment is determined. 507 508 Get the ABI (\a abi_or_pref == true) or preferred alignment (\a abi_or_pref 509 == false) for the requested type \a Ty. 510 */ 511 unsigned TargetData::getAlignment(Type *Ty, bool abi_or_pref) const { 512 int AlignType = -1; 513 514 assert(Ty->isSized() && "Cannot getTypeInfo() on a type that is unsized!"); 515 switch (Ty->getTypeID()) { 516 // Early escape for the non-numeric types. 517 case Type::LabelTyID: 518 case Type::PointerTyID: 519 return (abi_or_pref 520 ? getPointerABIAlignment() 521 : getPointerPrefAlignment()); 522 case Type::ArrayTyID: 523 return getAlignment(cast<ArrayType>(Ty)->getElementType(), abi_or_pref); 524 525 case Type::StructTyID: { 526 // Packed structure types always have an ABI alignment of one. 527 if (cast<StructType>(Ty)->isPacked() && abi_or_pref) 528 return 1; 529 530 // Get the layout annotation... which is lazily created on demand. 531 const StructLayout *Layout = getStructLayout(cast<StructType>(Ty)); 532 unsigned Align = getAlignmentInfo(AGGREGATE_ALIGN, 0, abi_or_pref, Ty); 533 return std::max(Align, Layout->getAlignment()); 534 } 535 case Type::IntegerTyID: 536 case Type::VoidTyID: 537 AlignType = INTEGER_ALIGN; 538 break; 539 case Type::HalfTyID: 540 case Type::FloatTyID: 541 case Type::DoubleTyID: 542 // PPC_FP128TyID and FP128TyID have different data contents, but the 543 // same size and alignment, so they look the same here. 544 case Type::PPC_FP128TyID: 545 case Type::FP128TyID: 546 case Type::X86_FP80TyID: 547 AlignType = FLOAT_ALIGN; 548 break; 549 case Type::X86_MMXTyID: 550 case Type::VectorTyID: 551 AlignType = VECTOR_ALIGN; 552 break; 553 default: 554 llvm_unreachable("Bad type for getAlignment!!!"); 555 } 556 557 return getAlignmentInfo((AlignTypeEnum)AlignType, getTypeSizeInBits(Ty), 558 abi_or_pref, Ty); 559 } 560 561 unsigned TargetData::getABITypeAlignment(Type *Ty) const { 562 return getAlignment(Ty, true); 563 } 564 565 /// getABIIntegerTypeAlignment - Return the minimum ABI-required alignment for 566 /// an integer type of the specified bitwidth. 567 unsigned TargetData::getABIIntegerTypeAlignment(unsigned BitWidth) const { 568 return getAlignmentInfo(INTEGER_ALIGN, BitWidth, true, 0); 569 } 570 571 572 unsigned TargetData::getCallFrameTypeAlignment(Type *Ty) const { 573 for (unsigned i = 0, e = Alignments.size(); i != e; ++i) 574 if (Alignments[i].AlignType == STACK_ALIGN) 575 return Alignments[i].ABIAlign; 576 577 return getABITypeAlignment(Ty); 578 } 579 580 unsigned TargetData::getPrefTypeAlignment(Type *Ty) const { 581 return getAlignment(Ty, false); 582 } 583 584 unsigned TargetData::getPreferredTypeAlignmentShift(Type *Ty) const { 585 unsigned Align = getPrefTypeAlignment(Ty); 586 assert(!(Align & (Align-1)) && "Alignment is not a power of two!"); 587 return Log2_32(Align); 588 } 589 590 /// getIntPtrType - Return an unsigned integer type that is the same size or 591 /// greater to the host pointer size. 592 IntegerType *TargetData::getIntPtrType(LLVMContext &C) const { 593 return IntegerType::get(C, getPointerSizeInBits()); 594 } 595 596 597 uint64_t TargetData::getIndexedOffset(Type *ptrTy, 598 ArrayRef<Value *> Indices) const { 599 Type *Ty = ptrTy; 600 assert(Ty->isPointerTy() && "Illegal argument for getIndexedOffset()"); 601 uint64_t Result = 0; 602 603 generic_gep_type_iterator<Value* const*> 604 TI = gep_type_begin(ptrTy, Indices); 605 for (unsigned CurIDX = 0, EndIDX = Indices.size(); CurIDX != EndIDX; 606 ++CurIDX, ++TI) { 607 if (StructType *STy = dyn_cast<StructType>(*TI)) { 608 assert(Indices[CurIDX]->getType() == 609 Type::getInt32Ty(ptrTy->getContext()) && 610 "Illegal struct idx"); 611 unsigned FieldNo = cast<ConstantInt>(Indices[CurIDX])->getZExtValue(); 612 613 // Get structure layout information... 614 const StructLayout *Layout = getStructLayout(STy); 615 616 // Add in the offset, as calculated by the structure layout info... 617 Result += Layout->getElementOffset(FieldNo); 618 619 // Update Ty to refer to current element 620 Ty = STy->getElementType(FieldNo); 621 } else { 622 // Update Ty to refer to current element 623 Ty = cast<SequentialType>(Ty)->getElementType(); 624 625 // Get the array index and the size of each array element. 626 if (int64_t arrayIdx = cast<ConstantInt>(Indices[CurIDX])->getSExtValue()) 627 Result += (uint64_t)arrayIdx * getTypeAllocSize(Ty); 628 } 629 } 630 631 return Result; 632 } 633 634 /// getPreferredAlignment - Return the preferred alignment of the specified 635 /// global. This includes an explicitly requested alignment (if the global 636 /// has one). 637 unsigned TargetData::getPreferredAlignment(const GlobalVariable *GV) const { 638 Type *ElemType = GV->getType()->getElementType(); 639 unsigned Alignment = getPrefTypeAlignment(ElemType); 640 unsigned GVAlignment = GV->getAlignment(); 641 if (GVAlignment >= Alignment) { 642 Alignment = GVAlignment; 643 } else if (GVAlignment != 0) { 644 Alignment = std::max(GVAlignment, getABITypeAlignment(ElemType)); 645 } 646 647 if (GV->hasInitializer() && GVAlignment == 0) { 648 if (Alignment < 16) { 649 // If the global is not external, see if it is large. If so, give it a 650 // larger alignment. 651 if (getTypeSizeInBits(ElemType) > 128) 652 Alignment = 16; // 16-byte alignment. 653 } 654 } 655 return Alignment; 656 } 657 658 /// getPreferredAlignmentLog - Return the preferred alignment of the 659 /// specified global, returned in log form. This includes an explicitly 660 /// requested alignment (if the global has one). 661 unsigned TargetData::getPreferredAlignmentLog(const GlobalVariable *GV) const { 662 return Log2_32(getPreferredAlignment(GV)); 663 } 664