Merge pull request #68191 from rjmccall/wip2-variadic-arg-translation

More progress towards variadic-tuple argument reabstraction

Author: rjmccall

lib/SILGen/ManagedValue.h

@@ -90,6 +90,7 @@ class ManagedValue {
   }
 
 public:
+  /// Constructs an invalid ManagedValue.
   ManagedValue() = default;
 
   /// Sometimes SILGen wants to represent an owned value or owned address
@@ -251,6 +252,10 @@ class ManagedValue {
     return ManagedValue(SILValue(), true, CleanupHandle::invalid());
   }
 
+  bool isValid() const {
+    return valueAndFlag.getInt() || valueAndFlag.getPointer();
+  }
+
   bool isLValue() const {
     return valueAndFlag.getInt() && valueAndFlag.getPointer();
   }

lib/SILGen/SILGenBuilder.cpp

@@ -486,6 +486,20 @@ ManagedValue SILGenBuilder::createLoadTake(SILLocation loc, ManagedValue v,
   return SGF.emitManagedRValueWithCleanup(result, lowering);
 }
 
+ManagedValue SILGenBuilder::createLoadTrivial(SILLocation loc,
+                                              ManagedValue addr) {
+#ifndef NDEBUG
+  auto &lowering = SGF.getTypeLowering(addr.getType());
+  assert(lowering.isTrivial());
+  assert((!lowering.isAddressOnly() || !SGF.silConv.useLoweredAddresses()) &&
+         "cannot load an unloadable type");
+  assert(!addr.hasCleanup());
+#endif
+  auto value = createLoad(loc, addr.getValue(),
+                          LoadOwnershipQualifier::Trivial);
+  return ManagedValue::forObjectRValueWithoutOwnership(value);
+}
+
 ManagedValue SILGenBuilder::createLoadCopy(SILLocation loc, ManagedValue v) {
   auto &lowering = SGF.getTypeLowering(v.getType());
   return createLoadCopy(loc, v, lowering);

lib/SILGen/SILGenBuilder.h

@@ -267,6 +267,8 @@ class SILGenBuilder : public SILBuilder {
   ManagedValue createLoadCopy(SILLocation loc, ManagedValue addr,
                               const TypeLowering &lowering);
 
+  ManagedValue createLoadTrivial(SILLocation loc, ManagedValue addr);
+
   /// Create a SILArgument for an input parameter. Asserts if used to create a
   /// function argument for an out parameter.
   ManagedValue createInputFunctionArgument(

lib/SILGen/SILGenFunction.h

@@ -2515,6 +2515,13 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
                                              CanPackType formalPackType,
                                              unsigned componentIndex);
 
+  /// Enter a cleanup to destroy the preceding components of a pack,
+  /// leading up to (but not including) a particular component index.
+  CleanupHandle
+  enterDestroyPrecedingPackComponentsCleanup(SILValue addr,
+                                             CanPackType formalPackType,
+                                             unsigned componentIndex);
+
   /// Enter a cleanup to destroy the preceding values in a pack-expansion
   /// component of a tuple.
   ///
@@ -2766,7 +2773,8 @@ class LLVM_LIBRARY_VISIBILITY SILGenFunction
   void emitDestroyPack(SILLocation loc,
                        SILValue packAddr,
                        CanPackType formalPackType,
-                       unsigned firstComponentIndex = 0);
+                       unsigned beginIndex,
+                       unsigned endIndex);
 
   /// Emit instructions to destroy a suffix of a tuple value.
   ///

lib/SILGen/SILGenPack.cpp

@@ -44,24 +44,26 @@ class DeallocPackCleanup : public Cleanup {
 class DestroyPackCleanup : public Cleanup {
   SILValue Addr;
   CanPackType FormalPackType;
-  unsigned FirstComponentIndex;
+  unsigned BeginIndex, EndIndex;
 public:
   DestroyPackCleanup(SILValue addr, CanPackType formalPackType,
-                     unsigned firstComponentIndex = 0)
+                     unsigned beginIndex, unsigned endIndex)
     : Addr(addr), FormalPackType(formalPackType),
-      FirstComponentIndex(firstComponentIndex) {}
+      BeginIndex(beginIndex), EndIndex(endIndex) {}
 
   void emit(SILGenFunction &SGF, CleanupLocation l,
             ForUnwind_t forUnwind) override {
-    SGF.emitDestroyPack(l, Addr, FormalPackType, FirstComponentIndex);
+    SGF.emitDestroyPack(l, Addr, FormalPackType, BeginIndex, EndIndex);
   }
 
   void dump(SILGenFunction &) const override {
 #ifndef NDEBUG
     llvm::errs() << "DestroyPackCleanup\n"
-                 << "State: " << getState() << "\n"
-                 << "Addr: " << Addr << "FormalPackType: " << FormalPackType
-                 << "FirstComponentIndex:" << FirstComponentIndex << "\n";
+                 << "State:" << getState() << "\n"
+                 << "Addr:" << Addr << "\n"
+                 << "FormalPackType:" << FormalPackType << "\n"
+                 << "BeginIndex:" << BeginIndex << "\n"
+                 << "EndIndex:" << EndIndex << "\n";
 #endif
   }
 };
@@ -295,19 +297,29 @@ CleanupHandle SILGenFunction::enterDeallocPackCleanup(SILValue temp) {
 
 CleanupHandle SILGenFunction::enterDestroyPackCleanup(SILValue addr,
                                                    CanPackType formalPackType) {
-  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType);
+  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
+                                           0, formalPackType->getNumElements());
   return Cleanups.getTopCleanup();
 }
 
 CleanupHandle
-SILGenFunction::enterDestroyRemainingPackComponentsCleanup(SILValue addr,
+SILGenFunction::enterDestroyPrecedingPackComponentsCleanup(SILValue addr,
                                                    CanPackType formalPackType,
                                                    unsigned componentIndex) {
   Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
-                                           componentIndex);
+                                           0, componentIndex);
   return Cleanups.getTopCleanup();
 }
 
+CleanupHandle
+SILGenFunction::enterDestroyRemainingPackComponentsCleanup(SILValue addr,
+                                                   CanPackType formalPackType,
+                                                   unsigned componentIndex) {
+  Cleanups.pushCleanup<DestroyPackCleanup>(addr, formalPackType,
+                                           componentIndex,
+                                           formalPackType->getNumElements());
+  return Cleanups.getTopCleanup();
+}
 
 CleanupHandle
 SILGenFunction::enterPartialDestroyPackCleanup(SILValue addr,
@@ -369,12 +381,15 @@ SILGenFunction::enterDestroyRemainingTupleElementsCleanup(SILValue addr,
 
 void SILGenFunction::emitDestroyPack(SILLocation loc, SILValue packAddr,
                                      CanPackType formalPackType,
-                                     unsigned firstComponentIndex) {
+                                     unsigned beginIndex,
+                                     unsigned endIndex) {
   auto packTy = packAddr->getType().castTo<SILPackType>();
 
+  assert(beginIndex <= endIndex);
+  assert(endIndex <= packTy->getNumElements());
+
   // Destroy each of the elements of the pack.
-  for (auto componentIndex :
-         range(firstComponentIndex, packTy->getNumElements())) {
+  for (auto componentIndex : range(beginIndex, endIndex)) {
     auto eltTy = packTy->getSILElementType(componentIndex);
 
     // We can skip this if the whole thing is trivial.