contrib/llvm-project/clang/lib/CodeGen/SwiftCallingConv.cpp

   1 //===--- SwiftCallingConv.cpp - Lowering for the Swift calling convention -===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8 //
   9 // Implementation of the abstract lowering for the Swift calling convention.
  10 //
  11 //===----------------------------------------------------------------------===//
  12
  13 #include "clang/CodeGen/SwiftCallingConv.h"
  14 #include "clang/Basic/TargetInfo.h"
  15 #include "CodeGenModule.h"
  16 #include "TargetInfo.h"
  17
  18 using namespace clang;
  19 using namespace CodeGen;
  20 using namespace swiftcall;
  21
  22 static const SwiftABIInfo &getSwiftABIInfo(CodeGenModule &CGM) {
  23   return cast<SwiftABIInfo>(CGM.getTargetCodeGenInfo().getABIInfo());
  24 }
  25
  26 static bool isPowerOf2(unsigned n) {
  27   return n == (n & -n);
  28 }
  29
  30 /// Given two types with the same size, try to find a common type.
  31 static llvm::Type *getCommonType(llvm::Type *first, llvm::Type *second) {
  32   assert(first != second);
  33
  34   // Allow pointers to merge with integers, but prefer the integer type.
  35   if (first->isIntegerTy()) {
  36     if (second->isPointerTy()) return first;
  37   } else if (first->isPointerTy()) {
  38     if (second->isIntegerTy()) return second;
  39     if (second->isPointerTy()) return first;
  40
  41   // Allow two vectors to be merged (given that they have the same size).
  42   // This assumes that we never have two different vector register sets.
  43   } else if (auto firstVecTy = dyn_cast<llvm::VectorType>(first)) {
  44     if (auto secondVecTy = dyn_cast<llvm::VectorType>(second)) {
  45       if (auto commonTy = getCommonType(firstVecTy->getElementType(),
  46                                         secondVecTy->getElementType())) {
  47         return (commonTy == firstVecTy->getElementType() ? first : second);
  48       }
  49     }
  50   }
  51
  52   return nullptr;
  53 }
  54
  55 static CharUnits getTypeStoreSize(CodeGenModule &CGM, llvm::Type *type) {
  56   return CharUnits::fromQuantity(CGM.getDataLayout().getTypeStoreSize(type));
  57 }
  58
  59 static CharUnits getTypeAllocSize(CodeGenModule &CGM, llvm::Type *type) {
  60   return CharUnits::fromQuantity(CGM.getDataLayout().getTypeAllocSize(type));
  61 }
  62
  63 void SwiftAggLowering::addTypedData(QualType type, CharUnits begin) {
  64   // Deal with various aggregate types as special cases:
  65
  66   // Record types.
  67   if (auto recType = type->getAs<RecordType>()) {
  68     addTypedData(recType->getDecl(), begin);
  69
  70   // Array types.
  71   } else if (type->isArrayType()) {
  72     // Incomplete array types (flexible array members?) don't provide
  73     // data to lay out, and the other cases shouldn't be possible.
  74     auto arrayType = CGM.getContext().getAsConstantArrayType(type);
  75     if (!arrayType) return;
  76
  77     QualType eltType = arrayType->getElementType();
  78     auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);
  79     for (uint64_t i = 0, e = arrayType->getSize().getZExtValue(); i != e; ++i) {
  80       addTypedData(eltType, begin + i * eltSize);
  81     }
  82
  83   // Complex types.
  84   } else if (auto complexType = type->getAs<ComplexType>()) {
  85     auto eltType = complexType->getElementType();
  86     auto eltSize = CGM.getContext().getTypeSizeInChars(eltType);
  87     auto eltLLVMType = CGM.getTypes().ConvertType(eltType);
  88     addTypedData(eltLLVMType, begin, begin + eltSize);
  89     addTypedData(eltLLVMType, begin + eltSize, begin + 2 * eltSize);
  90
  91   // Member pointer types.
  92   } else if (type->getAs<MemberPointerType>()) {
  93     // Just add it all as opaque.
  94     addOpaqueData(begin, begin + CGM.getContext().getTypeSizeInChars(type));
  95
  96   // Everything else is scalar and should not convert as an LLVM aggregate.
  97   } else {
  98     // We intentionally convert as !ForMem because we want to preserve
  99     // that a type was an i1.
 100     auto llvmType = CGM.getTypes().ConvertType(type);
 101     addTypedData(llvmType, begin);
 102   }
 103 }
 104
 105 void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin) {
 106   addTypedData(record, begin, CGM.getContext().getASTRecordLayout(record));
 107 }
 108
 109 void SwiftAggLowering::addTypedData(const RecordDecl *record, CharUnits begin,
 110                                     const ASTRecordLayout &layout) {
 111   // Unions are a special case.
 112   if (record->isUnion()) {
 113     for (auto field : record->fields()) {
 114       if (field->isBitField()) {
 115         addBitFieldData(field, begin, 0);
 116       } else {
 117         addTypedData(field->getType(), begin);
 118       }
 119     }
 120     return;
 121   }
 122
 123   // Note that correctness does not rely on us adding things in
 124   // their actual order of layout; it's just somewhat more efficient
 125   // for the builder.
 126
 127   // With that in mind, add "early" C++ data.
 128   auto cxxRecord = dyn_cast<CXXRecordDecl>(record);
 129   if (cxxRecord) {
 130     //   - a v-table pointer, if the class adds its own
 131     if (layout.hasOwnVFPtr()) {
 132       addTypedData(CGM.Int8PtrTy, begin);
 133     }
 134
 135     //   - non-virtual bases
 136     for (auto &baseSpecifier : cxxRecord->bases()) {
 137       if (baseSpecifier.isVirtual()) continue;
 138
 139       auto baseRecord = baseSpecifier.getType()->getAsCXXRecordDecl();
 140       addTypedData(baseRecord, begin + layout.getBaseClassOffset(baseRecord));
 141     }
 142
 143     //   - a vbptr if the class adds its own
 144     if (layout.hasOwnVBPtr()) {
 145       addTypedData(CGM.Int8PtrTy, begin + layout.getVBPtrOffset());
 146     }
 147   }
 148
 149   // Add fields.
 150   for (auto field : record->fields()) {
 151     auto fieldOffsetInBits = layout.getFieldOffset(field->getFieldIndex());
 152     if (field->isBitField()) {
 153       addBitFieldData(field, begin, fieldOffsetInBits);
 154     } else {
 155       addTypedData(field->getType(),
 156               begin + CGM.getContext().toCharUnitsFromBits(fieldOffsetInBits));
 157     }
 158   }
 159
 160   // Add "late" C++ data:
 161   if (cxxRecord) {
 162     //   - virtual bases
 163     for (auto &vbaseSpecifier : cxxRecord->vbases()) {
 164       auto baseRecord = vbaseSpecifier.getType()->getAsCXXRecordDecl();
 165       addTypedData(baseRecord, begin + layout.getVBaseClassOffset(baseRecord));
 166     }
 167   }
 168 }
 169
 170 void SwiftAggLowering::addBitFieldData(const FieldDecl *bitfield,
 171                                        CharUnits recordBegin,
 172                                        uint64_t bitfieldBitBegin) {
 173   assert(bitfield->isBitField());
 174   auto &ctx = CGM.getContext();
 175   auto width = bitfield->getBitWidthValue(ctx);
 176
 177   // We can ignore zero-width bit-fields.
 178   if (width == 0) return;
 179
 180   // toCharUnitsFromBits rounds down.
 181   CharUnits bitfieldByteBegin = ctx.toCharUnitsFromBits(bitfieldBitBegin);
 182
 183   // Find the offset of the last byte that is partially occupied by the
 184   // bit-field; since we otherwise expect exclusive ends, the end is the
 185   // next byte.
 186   uint64_t bitfieldBitLast = bitfieldBitBegin + width - 1;
 187   CharUnits bitfieldByteEnd =
 188     ctx.toCharUnitsFromBits(bitfieldBitLast) + CharUnits::One();
 189   addOpaqueData(recordBegin + bitfieldByteBegin,
 190                 recordBegin + bitfieldByteEnd);
 191 }
 192
 193 void SwiftAggLowering::addTypedData(llvm::Type *type, CharUnits begin) {
 194   assert(type && "didn't provide type for typed data");
 195   addTypedData(type, begin, begin + getTypeStoreSize(CGM, type));
 196 }
 197
 198 void SwiftAggLowering::addTypedData(llvm::Type *type,
 199                                     CharUnits begin, CharUnits end) {
 200   assert(type && "didn't provide type for typed data");
 201   assert(getTypeStoreSize(CGM, type) == end - begin);
 202
 203   // Legalize vector types.
 204   if (auto vecTy = dyn_cast<llvm::VectorType>(type)) {
 205     SmallVector<llvm::Type*, 4> componentTys;
 206     legalizeVectorType(CGM, end - begin, vecTy, componentTys);
 207     assert(componentTys.size() >= 1);
 208
 209     // Walk the initial components.
 210     for (size_t i = 0, e = componentTys.size(); i != e - 1; ++i) {
 211       llvm::Type *componentTy = componentTys[i];
 212       auto componentSize = getTypeStoreSize(CGM, componentTy);
 213       assert(componentSize < end - begin);
 214       addLegalTypedData(componentTy, begin, begin + componentSize);
 215       begin += componentSize;
 216     }
 217
 218     return addLegalTypedData(componentTys.back(), begin, end);
 219   }
 220
 221   // Legalize integer types.
 222   if (auto intTy = dyn_cast<llvm::IntegerType>(type)) {
 223     if (!isLegalIntegerType(CGM, intTy))
 224       return addOpaqueData(begin, end);
 225   }
 226
 227   // All other types should be legal.
 228   return addLegalTypedData(type, begin, end);
 229 }
 230
 231 void SwiftAggLowering::addLegalTypedData(llvm::Type *type,
 232                                          CharUnits begin, CharUnits end) {
 233   // Require the type to be naturally aligned.
 234   if (!begin.isZero() && !begin.isMultipleOf(getNaturalAlignment(CGM, type))) {
 235
 236     // Try splitting vector types.
 237     if (auto vecTy = dyn_cast<llvm::VectorType>(type)) {
 238       auto split = splitLegalVectorType(CGM, end - begin, vecTy);
 239       auto eltTy = split.first;
 240       auto numElts = split.second;
 241
 242       auto eltSize = (end - begin) / numElts;
 243       assert(eltSize == getTypeStoreSize(CGM, eltTy));
 244       for (size_t i = 0, e = numElts; i != e; ++i) {
 245         addLegalTypedData(eltTy, begin, begin + eltSize);
 246         begin += eltSize;
 247       }
 248       assert(begin == end);
 249       return;
 250     }
 251
 252     return addOpaqueData(begin, end);
 253   }
 254
 255   addEntry(type, begin, end);
 256 }
 257
 258 void SwiftAggLowering::addEntry(llvm::Type *type,
 259                                 CharUnits begin, CharUnits end) {
 260   assert((!type ||
 261           (!isa<llvm::StructType>(type) && !isa<llvm::ArrayType>(type))) &&
 262          "cannot add aggregate-typed data");
 263   assert(!type || begin.isMultipleOf(getNaturalAlignment(CGM, type)));
 264
 265   // Fast path: we can just add entries to the end.
 266   if (Entries.empty() || Entries.back().End <= begin) {
 267     Entries.push_back({begin, end, type});
 268     return;
 269   }
 270
 271   // Find the first existing entry that ends after the start of the new data.
 272   // TODO: do a binary search if Entries is big enough for it to matter.
 273   size_t index = Entries.size() - 1;
 274   while (index != 0) {
 275     if (Entries[index - 1].End <= begin) break;
 276     --index;
 277   }
 278
 279   // The entry ends after the start of the new data.
 280   // If the entry starts after the end of the new data, there's no conflict.
 281   if (Entries[index].Begin >= end) {
 282     // This insertion is potentially O(n), but the way we generally build
 283     // these layouts makes that unlikely to matter: we'd need a union of
 284     // several very large types.
 285     Entries.insert(Entries.begin() + index, {begin, end, type});
 286     return;
 287   }
 288
 289   // Otherwise, the ranges overlap.  The new range might also overlap
 290   // with later ranges.
 291 restartAfterSplit:
 292
 293   // Simplest case: an exact overlap.
 294   if (Entries[index].Begin == begin && Entries[index].End == end) {
 295     // If the types match exactly, great.
 296     if (Entries[index].Type == type) return;
 297
 298     // If either type is opaque, make the entry opaque and return.
 299     if (Entries[index].Type == nullptr) {
 300       return;
 301     } else if (type == nullptr) {
 302       Entries[index].Type = nullptr;
 303       return;
 304     }
 305
 306     // If they disagree in an ABI-agnostic way, just resolve the conflict
 307     // arbitrarily.
 308     if (auto entryType = getCommonType(Entries[index].Type, type)) {
 309       Entries[index].Type = entryType;
 310       return;
 311     }
 312
 313     // Otherwise, make the entry opaque.
 314     Entries[index].Type = nullptr;
 315     return;
 316   }
 317
 318   // Okay, we have an overlapping conflict of some sort.
 319
 320   // If we have a vector type, split it.
 321   if (auto vecTy = dyn_cast_or_null<llvm::VectorType>(type)) {
 322     auto eltTy = vecTy->getElementType();
 323     CharUnits eltSize = (end - begin) / vecTy->getNumElements();
 324     assert(eltSize == getTypeStoreSize(CGM, eltTy));
 325     for (unsigned i = 0, e = vecTy->getNumElements(); i != e; ++i) {
 326       addEntry(eltTy, begin, begin + eltSize);
 327       begin += eltSize;
 328     }
 329     assert(begin == end);
 330     return;
 331   }
 332
 333   // If the entry is a vector type, split it and try again.
 334   if (Entries[index].Type && Entries[index].Type->isVectorTy()) {
 335     splitVectorEntry(index);
 336     goto restartAfterSplit;
 337   }
 338
 339   // Okay, we have no choice but to make the existing entry opaque.
 340
 341   Entries[index].Type = nullptr;
 342
 343   // Stretch the start of the entry to the beginning of the range.
 344   if (begin < Entries[index].Begin) {
 345     Entries[index].Begin = begin;
 346     assert(index == 0 || begin >= Entries[index - 1].End);
 347   }
 348
 349   // Stretch the end of the entry to the end of the range; but if we run
 350   // into the start of the next entry, just leave the range there and repeat.
 351   while (end > Entries[index].End) {
 352     assert(Entries[index].Type == nullptr);
 353
 354     // If the range doesn't overlap the next entry, we're done.
 355     if (index == Entries.size() - 1 || end <= Entries[index + 1].Begin) {
 356       Entries[index].End = end;
 357       break;
 358     }
 359
 360     // Otherwise, stretch to the start of the next entry.
 361     Entries[index].End = Entries[index + 1].Begin;
 362
 363     // Continue with the next entry.
 364     index++;
 365
 366     // This entry needs to be made opaque if it is not already.
 367     if (Entries[index].Type == nullptr)
 368       continue;
 369
 370     // Split vector entries unless we completely subsume them.
 371     if (Entries[index].Type->isVectorTy() &&
 372         end < Entries[index].End) {
 373       splitVectorEntry(index);
 374     }
 375
 376     // Make the entry opaque.
 377     Entries[index].Type = nullptr;
 378   }
 379 }
 380
 381 /// Replace the entry of vector type at offset 'index' with a sequence
 382 /// of its component vectors.
 383 void SwiftAggLowering::splitVectorEntry(unsigned index) {
 384   auto vecTy = cast<llvm::VectorType>(Entries[index].Type);
 385   auto split = splitLegalVectorType(CGM, Entries[index].getWidth(), vecTy);
 386
 387   auto eltTy = split.first;
 388   CharUnits eltSize = getTypeStoreSize(CGM, eltTy);
 389   auto numElts = split.second;
 390   Entries.insert(Entries.begin() + index + 1, numElts - 1, StorageEntry());
 391
 392   CharUnits begin = Entries[index].Begin;
 393   for (unsigned i = 0; i != numElts; ++i) {
 394     Entries[index].Type = eltTy;
 395     Entries[index].Begin = begin;
 396     Entries[index].End = begin + eltSize;
 397     begin += eltSize;
 398   }
 399 }
 400
 401 /// Given a power-of-two unit size, return the offset of the aligned unit
 402 /// of that size which contains the given offset.
 403 ///
 404 /// In other words, round down to the nearest multiple of the unit size.
 405 static CharUnits getOffsetAtStartOfUnit(CharUnits offset, CharUnits unitSize) {
 406   assert(isPowerOf2(unitSize.getQuantity()));
 407   auto unitMask = ~(unitSize.getQuantity() - 1);
 408   return CharUnits::fromQuantity(offset.getQuantity() & unitMask);
 409 }
 410
 411 static bool areBytesInSameUnit(CharUnits first, CharUnits second,
 412                                CharUnits chunkSize) {
 413   return getOffsetAtStartOfUnit(first, chunkSize)
 414       == getOffsetAtStartOfUnit(second, chunkSize);
 415 }
 416
 417 static bool isMergeableEntryType(llvm::Type *type) {
 418   // Opaquely-typed memory is always mergeable.
 419   if (type == nullptr) return true;
 420
 421   // Pointers and integers are always mergeable.  In theory we should not
 422   // merge pointers, but (1) it doesn't currently matter in practice because
 423   // the chunk size is never greater than the size of a pointer and (2)
 424   // Swift IRGen uses integer types for a lot of things that are "really"
 425   // just storing pointers (like Optional<SomePointer>).  If we ever have a
 426   // target that would otherwise combine pointers, we should put some effort
 427   // into fixing those cases in Swift IRGen and then call out pointer types
 428   // here.
 429
 430   // Floating-point and vector types should never be merged.
 431   // Most such types are too large and highly-aligned to ever trigger merging
 432   // in practice, but it's important for the rule to cover at least 'half'
 433   // and 'float', as well as things like small vectors of 'i1' or 'i8'.
 434   return (!type->isFloatingPointTy() && !type->isVectorTy());
 435 }
 436
 437 bool SwiftAggLowering::shouldMergeEntries(const StorageEntry &first,
 438                                           const StorageEntry &second,
 439                                           CharUnits chunkSize) {
 440   // Only merge entries that overlap the same chunk.  We test this first
 441   // despite being a bit more expensive because this is the condition that
 442   // tends to prevent merging.
 443   if (!areBytesInSameUnit(first.End - CharUnits::One(), second.Begin,
 444                           chunkSize))
 445     return false;
 446
 447   return (isMergeableEntryType(first.Type) &&
 448           isMergeableEntryType(second.Type));
 449 }
 450
 451 void SwiftAggLowering::finish() {
 452   if (Entries.empty()) {
 453     Finished = true;
 454     return;
 455   }
 456
 457   // We logically split the layout down into a series of chunks of this size,
 458   // which is generally the size of a pointer.
 459   const CharUnits chunkSize = getMaximumVoluntaryIntegerSize(CGM);
 460
 461   // First pass: if two entries should be merged, make them both opaque
 462   // and stretch one to meet the next.
 463   // Also, remember if there are any opaque entries.
 464   bool hasOpaqueEntries = (Entries[0].Type == nullptr);
 465   for (size_t i = 1, e = Entries.size(); i != e; ++i) {
 466     if (shouldMergeEntries(Entries[i - 1], Entries[i], chunkSize)) {
 467       Entries[i - 1].Type = nullptr;
 468       Entries[i].Type = nullptr;
 469       Entries[i - 1].End = Entries[i].Begin;
 470       hasOpaqueEntries = true;
 471
 472     } else if (Entries[i].Type == nullptr) {
 473       hasOpaqueEntries = true;
 474     }
 475   }
 476
 477   // The rest of the algorithm leaves non-opaque entries alone, so if we
 478   // have no opaque entries, we're done.
 479   if (!hasOpaqueEntries) {
 480     Finished = true;
 481     return;
 482   }
 483
 484   // Okay, move the entries to a temporary and rebuild Entries.
 485   auto orig = std::move(Entries);
 486   assert(Entries.empty());
 487
 488   for (size_t i = 0, e = orig.size(); i != e; ++i) {
 489     // Just copy over non-opaque entries.
 490     if (orig[i].Type != nullptr) {
 491       Entries.push_back(orig[i]);
 492       continue;
 493     }
 494
 495     // Scan forward to determine the full extent of the next opaque range.
 496     // We know from the first pass that only contiguous ranges will overlap
 497     // the same aligned chunk.
 498     auto begin = orig[i].Begin;
 499     auto end = orig[i].End;
 500     while (i + 1 != e &&
 501            orig[i + 1].Type == nullptr &&
 502            end == orig[i + 1].Begin) {
 503       end = orig[i + 1].End;
 504       i++;
 505     }
 506
 507     // Add an entry per intersected chunk.
 508     do {
 509       // Find the smallest aligned storage unit in the maximal aligned
 510       // storage unit containing 'begin' that contains all the bytes in
 511       // the intersection between the range and this chunk.
 512       CharUnits localBegin = begin;
 513       CharUnits chunkBegin = getOffsetAtStartOfUnit(localBegin, chunkSize);
 514       CharUnits chunkEnd = chunkBegin + chunkSize;
 515       CharUnits localEnd = std::min(end, chunkEnd);
 516
 517       // Just do a simple loop over ever-increasing unit sizes.
 518       CharUnits unitSize = CharUnits::One();
 519       CharUnits unitBegin, unitEnd;
 520       for (; ; unitSize *= 2) {
 521         assert(unitSize <= chunkSize);
 522         unitBegin = getOffsetAtStartOfUnit(localBegin, unitSize);
 523         unitEnd = unitBegin + unitSize;
 524         if (unitEnd >= localEnd) break;
 525       }
 526
 527       // Add an entry for this unit.
 528       auto entryTy =
 529         llvm::IntegerType::get(CGM.getLLVMContext(),
 530                                CGM.getContext().toBits(unitSize));
 531       Entries.push_back({unitBegin, unitEnd, entryTy});
 532
 533       // The next chunk starts where this chunk left off.
 534       begin = localEnd;
 535     } while (begin != end);
 536   }
 537
 538   // Okay, finally finished.
 539   Finished = true;
 540 }
 541
 542 void SwiftAggLowering::enumerateComponents(EnumerationCallback callback) const {
 543   assert(Finished && "haven't yet finished lowering");
 544
 545   for (auto &entry : Entries) {
 546     callback(entry.Begin, entry.End, entry.Type);
 547   }
 548 }
 549
 550 std::pair<llvm::StructType*, llvm::Type*>
 551 SwiftAggLowering::getCoerceAndExpandTypes() const {
 552   assert(Finished && "haven't yet finished lowering");
 553
 554   auto &ctx = CGM.getLLVMContext();
 555
 556   if (Entries.empty()) {
 557     auto type = llvm::StructType::get(ctx);
 558     return { type, type };
 559   }
 560
 561   SmallVector<llvm::Type*, 8> elts;
 562   CharUnits lastEnd = CharUnits::Zero();
 563   bool hasPadding = false;
 564   bool packed = false;
 565   for (auto &entry : Entries) {
 566     if (entry.Begin != lastEnd) {
 567       auto paddingSize = entry.Begin - lastEnd;
 568       assert(!paddingSize.isNegative());
 569
 570       auto padding = llvm::ArrayType::get(llvm::Type::getInt8Ty(ctx),
 571                                           paddingSize.getQuantity());
 572       elts.push_back(padding);
 573       hasPadding = true;
 574     }
 575
 576     if (!packed && !entry.Begin.isMultipleOf(
 577           CharUnits::fromQuantity(
 578             CGM.getDataLayout().getABITypeAlignment(entry.Type))))
 579       packed = true;
 580
 581     elts.push_back(entry.Type);
 582
 583     lastEnd = entry.Begin + getTypeAllocSize(CGM, entry.Type);
 584     assert(entry.End <= lastEnd);
 585   }
 586
 587   // We don't need to adjust 'packed' to deal with possible tail padding
 588   // because we never do that kind of access through the coercion type.
 589   auto coercionType = llvm::StructType::get(ctx, elts, packed);
 590
 591   llvm::Type *unpaddedType = coercionType;
 592   if (hasPadding) {
 593     elts.clear();
 594     for (auto &entry : Entries) {
 595       elts.push_back(entry.Type);
 596     }
 597     if (elts.size() == 1) {
 598       unpaddedType = elts[0];
 599     } else {
 600       unpaddedType = llvm::StructType::get(ctx, elts, /*packed*/ false);
 601     }
 602   } else if (Entries.size() == 1) {
 603     unpaddedType = Entries[0].Type;
 604   }
 605
 606   return { coercionType, unpaddedType };
 607 }
 608
 609 bool SwiftAggLowering::shouldPassIndirectly(bool asReturnValue) const {
 610   assert(Finished && "haven't yet finished lowering");
 611
 612   // Empty types don't need to be passed indirectly.
 613   if (Entries.empty()) return false;
 614
 615   // Avoid copying the array of types when there's just a single element.
 616   if (Entries.size() == 1) {
 617     return getSwiftABIInfo(CGM).shouldPassIndirectlyForSwift(
 618                                                            Entries.back().Type,
 619                                                              asReturnValue);
 620   }
 621
 622   SmallVector<llvm::Type*, 8> componentTys;
 623   componentTys.reserve(Entries.size());
 624   for (auto &entry : Entries) {
 625     componentTys.push_back(entry.Type);
 626   }
 627   return getSwiftABIInfo(CGM).shouldPassIndirectlyForSwift(componentTys,
 628                                                            asReturnValue);
 629 }
 630
 631 bool swiftcall::shouldPassIndirectly(CodeGenModule &CGM,
 632                                      ArrayRef<llvm::Type*> componentTys,
 633                                      bool asReturnValue) {
 634   return getSwiftABIInfo(CGM).shouldPassIndirectlyForSwift(componentTys,
 635                                                            asReturnValue);
 636 }
 637
 638 CharUnits swiftcall::getMaximumVoluntaryIntegerSize(CodeGenModule &CGM) {
 639   // Currently always the size of an ordinary pointer.
 640   return CGM.getContext().toCharUnitsFromBits(
 641            CGM.getContext().getTargetInfo().getPointerWidth(0));
 642 }
 643
 644 CharUnits swiftcall::getNaturalAlignment(CodeGenModule &CGM, llvm::Type *type) {
 645   // For Swift's purposes, this is always just the store size of the type
 646   // rounded up to a power of 2.
 647   auto size = (unsigned long long) getTypeStoreSize(CGM, type).getQuantity();
 648   if (!isPowerOf2(size)) {
 649     size = 1ULL << (llvm::findLastSet(size, llvm::ZB_Undefined) + 1);
 650   }
 651   assert(size >= CGM.getDataLayout().getABITypeAlignment(type));
 652   return CharUnits::fromQuantity(size);
 653 }
 654
 655 bool swiftcall::isLegalIntegerType(CodeGenModule &CGM,
 656                                    llvm::IntegerType *intTy) {
 657   auto size = intTy->getBitWidth();
 658   switch (size) {
 659   case 1:
 660   case 8:
 661   case 16:
 662   case 32:
 663   case 64:
 664     // Just assume that the above are always legal.
 665     return true;
 666
 667   case 128:
 668     return CGM.getContext().getTargetInfo().hasInt128Type();
 669
 670   default:
 671     return false;
 672   }
 673 }
 674
 675 bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
 676                                   llvm::VectorType *vectorTy) {
 677   return isLegalVectorType(CGM, vectorSize, vectorTy->getElementType(),
 678                            vectorTy->getNumElements());
 679 }
 680
 681 bool swiftcall::isLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
 682                                   llvm::Type *eltTy, unsigned numElts) {
 683   assert(numElts > 1 && "illegal vector length");
 684   return getSwiftABIInfo(CGM)
 685            .isLegalVectorTypeForSwift(vectorSize, eltTy, numElts);
 686 }
 687
 688 std::pair<llvm::Type*, unsigned>
 689 swiftcall::splitLegalVectorType(CodeGenModule &CGM, CharUnits vectorSize,
 690                                 llvm::VectorType *vectorTy) {
 691   auto numElts = vectorTy->getNumElements();
 692   auto eltTy = vectorTy->getElementType();
 693
 694   // Try to split the vector type in half.
 695   if (numElts >= 4 && isPowerOf2(numElts)) {
 696     if (isLegalVectorType(CGM, vectorSize / 2, eltTy, numElts / 2))
 697       return {llvm::VectorType::get(eltTy, numElts / 2), 2};
 698   }
 699
 700   return {eltTy, numElts};
 701 }
 702
 703 void swiftcall::legalizeVectorType(CodeGenModule &CGM, CharUnits origVectorSize,
 704                                    llvm::VectorType *origVectorTy,
 705                              llvm::SmallVectorImpl<llvm::Type*> &components) {
 706   // If it's already a legal vector type, use it.
 707   if (isLegalVectorType(CGM, origVectorSize, origVectorTy)) {
 708     components.push_back(origVectorTy);
 709     return;
 710   }
 711
 712   // Try to split the vector into legal subvectors.
 713   auto numElts = origVectorTy->getNumElements();
 714   auto eltTy = origVectorTy->getElementType();
 715   assert(numElts != 1);
 716
 717   // The largest size that we're still considering making subvectors of.
 718   // Always a power of 2.
 719   unsigned logCandidateNumElts = llvm::findLastSet(numElts, llvm::ZB_Undefined);
 720   unsigned candidateNumElts = 1U << logCandidateNumElts;
 721   assert(candidateNumElts <= numElts && candidateNumElts * 2 > numElts);
 722
 723   // Minor optimization: don't check the legality of this exact size twice.
 724   if (candidateNumElts == numElts) {
 725     logCandidateNumElts--;
 726     candidateNumElts >>= 1;
 727   }
 728
 729   CharUnits eltSize = (origVectorSize / numElts);
 730   CharUnits candidateSize = eltSize * candidateNumElts;
 731
 732   // The sensibility of this algorithm relies on the fact that we never
 733   // have a legal non-power-of-2 vector size without having the power of 2
 734   // also be legal.
 735   while (logCandidateNumElts > 0) {
 736     assert(candidateNumElts == 1U << logCandidateNumElts);
 737     assert(candidateNumElts <= numElts);
 738     assert(candidateSize == eltSize * candidateNumElts);
 739
 740     // Skip illegal vector sizes.
 741     if (!isLegalVectorType(CGM, candidateSize, eltTy, candidateNumElts)) {
 742       logCandidateNumElts--;
 743       candidateNumElts /= 2;
 744       candidateSize /= 2;
 745       continue;
 746     }
 747
 748     // Add the right number of vectors of this size.
 749     auto numVecs = numElts >> logCandidateNumElts;
 750     components.append(numVecs, llvm::VectorType::get(eltTy, candidateNumElts));
 751     numElts -= (numVecs << logCandidateNumElts);
 752
 753     if (numElts == 0) return;
 754
 755     // It's possible that the number of elements remaining will be legal.
 756     // This can happen with e.g. <7 x float> when <3 x float> is legal.
 757     // This only needs to be separately checked if it's not a power of 2.
 758     if (numElts > 2 && !isPowerOf2(numElts) &&
 759         isLegalVectorType(CGM, eltSize * numElts, eltTy, numElts)) {
 760       components.push_back(llvm::VectorType::get(eltTy, numElts));
 761       return;
 762     }
 763
 764     // Bring vecSize down to something no larger than numElts.
 765     do {
 766       logCandidateNumElts--;
 767       candidateNumElts /= 2;
 768       candidateSize /= 2;
 769     } while (candidateNumElts > numElts);
 770   }
 771
 772   // Otherwise, just append a bunch of individual elements.
 773   components.append(numElts, eltTy);
 774 }
 775
 776 bool swiftcall::mustPassRecordIndirectly(CodeGenModule &CGM,
 777                                          const RecordDecl *record) {
 778   // FIXME: should we not rely on the standard computation in Sema, just in
 779   // case we want to diverge from the platform ABI (e.g. on targets where
 780   // that uses the MSVC rule)?
 781   return !record->canPassInRegisters();
 782 }
 783
 784 static ABIArgInfo classifyExpandedType(SwiftAggLowering &lowering,
 785                                        bool forReturn,
 786                                        CharUnits alignmentForIndirect) {
 787   if (lowering.empty()) {
 788     return ABIArgInfo::getIgnore();
 789   } else if (lowering.shouldPassIndirectly(forReturn)) {
 790     return ABIArgInfo::getIndirect(alignmentForIndirect, /*byval*/ false);
 791   } else {
 792     auto types = lowering.getCoerceAndExpandTypes();
 793     return ABIArgInfo::getCoerceAndExpand(types.first, types.second);
 794   }
 795 }
 796
 797 static ABIArgInfo classifyType(CodeGenModule &CGM, CanQualType type,
 798                                bool forReturn) {
 799   if (auto recordType = dyn_cast<RecordType>(type)) {
 800     auto record = recordType->getDecl();
 801     auto &layout = CGM.getContext().getASTRecordLayout(record);
 802
 803     if (mustPassRecordIndirectly(CGM, record))
 804       return ABIArgInfo::getIndirect(layout.getAlignment(), /*byval*/ false);
 805
 806     SwiftAggLowering lowering(CGM);
 807     lowering.addTypedData(recordType->getDecl(), CharUnits::Zero(), layout);
 808     lowering.finish();
 809
 810     return classifyExpandedType(lowering, forReturn, layout.getAlignment());
 811   }
 812
 813   // Just assume that all of our target ABIs can support returning at least
 814   // two integer or floating-point values.
 815   if (isa<ComplexType>(type)) {
 816     return (forReturn ? ABIArgInfo::getDirect() : ABIArgInfo::getExpand());
 817   }
 818
 819   // Vector types may need to be legalized.
 820   if (isa<VectorType>(type)) {
 821     SwiftAggLowering lowering(CGM);
 822     lowering.addTypedData(type, CharUnits::Zero());
 823     lowering.finish();
 824
 825     CharUnits alignment = CGM.getContext().getTypeAlignInChars(type);
 826     return classifyExpandedType(lowering, forReturn, alignment);
 827   }
 828
 829   // Member pointer types need to be expanded, but it's a simple form of
 830   // expansion that 'Direct' can handle.  Note that CanBeFlattened should be
 831   // true for this to work.
 832
 833   // 'void' needs to be ignored.
 834   if (type->isVoidType()) {
 835     return ABIArgInfo::getIgnore();
 836   }
 837
 838   // Everything else can be passed directly.
 839   return ABIArgInfo::getDirect();
 840 }
 841
 842 ABIArgInfo swiftcall::classifyReturnType(CodeGenModule &CGM, CanQualType type) {
 843   return classifyType(CGM, type, /*forReturn*/ true);
 844 }
 845
 846 ABIArgInfo swiftcall::classifyArgumentType(CodeGenModule &CGM,
 847                                            CanQualType type) {
 848   return classifyType(CGM, type, /*forReturn*/ false);
 849 }
 850
 851 void swiftcall::computeABIInfo(CodeGenModule &CGM, CGFunctionInfo &FI) {
 852   auto &retInfo = FI.getReturnInfo();
 853   retInfo = classifyReturnType(CGM, FI.getReturnType());
 854
 855   for (unsigned i = 0, e = FI.arg_size(); i != e; ++i) {
 856     auto &argInfo = FI.arg_begin()[i];
 857     argInfo.info = classifyArgumentType(CGM, argInfo.type);
 858   }
 859 }
 860
 861 // Is swifterror lowered to a register by the target ABI.
 862 bool swiftcall::isSwiftErrorLoweredInRegister(CodeGenModule &CGM) {
 863   return getSwiftABIInfo(CGM).isSwiftErrorInRegister();
 864 }