Fix some SILArgument infrastructure for pack results.

Getting this right convinces the memory verifier to not complain
about untouched empty pack result arguments, which should be
innocuous.

Author: rjmccall

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -137,11 +137,17 @@ public enum ArgumentConvention {
   /// indirectly is recorded in the pack type.
   case packGuaranteed
 
+  /// This argument is a pack of indirect return value addresses.  The
+  /// addresses are stored in the pack by the caller and read out by the
+  /// callee; within the callee, they are individually treated like
+  /// indirectOut arguments.
+  case packOut
+
   public var isIndirect: Bool {
     switch self {
     case .indirectIn, .indirectInGuaranteed,
          .indirectInout, .indirectInoutAliasable, .indirectOut,
-         .packInout, .packOwned, .packGuaranteed:
+         .packOut, .packInout, .packOwned, .packGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed:
       return false
@@ -155,7 +161,19 @@ public enum ArgumentConvention {
       return true
     case .directOwned, .directUnowned, .directGuaranteed,
          .indirectInout, .indirectInoutAliasable, .indirectOut,
-         .packInout:
+         .packOut, .packInout:
+      return false
+    }
+  }
+
+  public var isIndirectOut: Bool {
+    switch self {
+    case .indirectOut, .packOut:
+      return true
+    case .indirectInGuaranteed, .directGuaranteed, .packGuaranteed,
+         .indirectIn, .directOwned, .directUnowned,
+         .indirectInout, .indirectInoutAliasable,
+         .packInout, .packOwned:
       return false
     }
   }
@@ -166,7 +184,7 @@ public enum ArgumentConvention {
       return true
     case .indirectIn, .directOwned, .directUnowned,
          .indirectInout, .indirectInoutAliasable, .indirectOut,
-         .packInout, .packOwned:
+         .packOut, .packInout, .packOwned:
       return false
     }
   }
@@ -177,6 +195,7 @@ public enum ArgumentConvention {
          .indirectOut,
          .indirectInGuaranteed,
          .indirectInout,
+         .packOut,
          .packInout,
          .packOwned,
          .packGuaranteed:
@@ -203,6 +222,7 @@ public enum ArgumentConvention {
          .directUnowned,
          .directGuaranteed,
          .directOwned,
+         .packOut,
          .packOwned,
          .packGuaranteed:
       return false
@@ -229,6 +249,7 @@ extension BridgedArgumentConvention {
       case .Direct_Owned:            return .directOwned
       case .Direct_Unowned:          return .directUnowned
       case .Direct_Guaranteed:       return .directGuaranteed
+      case .Pack_Out:                return .packOut
       case .Pack_Inout:              return .packInout
       case .Pack_Owned:              return .packOwned
       case .Pack_Guaranteed:         return .packGuaranteed

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -143,7 +143,7 @@ extension Function {
       if convention.isIndirectIn {
         // Even a `[readnone]` function can read from an indirect argument.
         result.memory.read = true
-      } else if convention == .indirectOut {
+      } else if convention.isIndirectOut {
         // Even `[readnone]` and `[readonly]` functions write to indirect results.
         result.memory.write = true
       }
@@ -546,7 +546,7 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
       case .indirectInGuaranteed, .packGuaranteed:
         result.memory.write = false
         result.ownership.destroy = false
-      case .indirectOut, .packInout:
+      case .indirectOut, .packOut, .packInout:
         result.memory.read = false
         result.ownership.copy = false
         result.ownership.destroy = false

SwiftCompilerSources/Sources/SIL/Function.swift

@@ -83,9 +83,6 @@ final public class Function : CustomStringConvertible, HasShortDescription, Hash
   public var resultType: Type { bridged.getSILResultType().type }
 
   public func getArgumentConvention(for argumentIndex: Int) -> ArgumentConvention {
-    if argumentIndex < numIndirectResultArguments {
-      return .indirectOut
-    }
     return bridged.getSILArgumentConvention(argumentIndex).convention
   }
 

include/swift/SIL/SILArgument.h

@@ -28,19 +28,6 @@ class SILPhiArgument;
 class SILUndef;
 class TermInst;
 
-// Map an argument index onto a SILArgumentConvention.
-inline SILArgumentConvention
-SILFunctionConventions::getSILArgumentConvention(unsigned index) const {
-  assert(index <= getNumSILArguments());
-  if (index < getNumIndirectSILResults()) {
-    assert(silConv.loweredAddresses);
-    return SILArgumentConvention::Indirect_Out;
-  } else {
-    auto param = funcTy->getParameters()[index - getNumIndirectSILResults()];
-    return SILArgumentConvention(param.getConvention());
-  }
-}
-
 struct SILArgumentKind {
   enum innerty : std::underlying_type<ValueKind>::type {
 #define ARGUMENT(ID, PARENT) ID = unsigned(SILNodeKind::ID),

include/swift/SIL/SILArgumentConvention.h

@@ -164,6 +164,28 @@ struct SILArgumentConvention {
     }
     llvm_unreachable("covered switch isn't covered?!");
   }
+
+  /// Returns true if \p Value is an indirect-out parameter.
+  bool isIndirectOutParameter() {
+    switch (Value) {
+    case SILArgumentConvention::Indirect_Out:
+    case SILArgumentConvention::Pack_Out:
+      return true;
+
+    case SILArgumentConvention::Indirect_In:
+    case SILArgumentConvention::Indirect_In_Guaranteed:
+    case SILArgumentConvention::Indirect_Inout:
+    case SILArgumentConvention::Indirect_InoutAliasable:
+    case SILArgumentConvention::Direct_Unowned:
+    case SILArgumentConvention::Direct_Guaranteed:
+    case SILArgumentConvention::Direct_Owned:
+    case SILArgumentConvention::Pack_Inout:
+    case SILArgumentConvention::Pack_Owned:
+    case SILArgumentConvention::Pack_Guaranteed:
+      return false;
+    }
+    llvm_unreachable("covered switch isn't covered?!");
+  }
 };
 
 } // namespace swift

include/swift/SIL/SILBridging.h

@@ -212,7 +212,7 @@ struct BridgedFunction {
 
   BridgedArgumentConvention getSILArgumentConvention(SwiftInt idx) const {
     swift::SILFunctionConventions conv(getFunction()->getConventionsInContext());
-    return castToArgumentConvention(swift::SILArgumentConvention(conv.getParamInfoForSILArg(idx).getConvention()));
+    return castToArgumentConvention(conv.getSILArgumentConvention(idx));
   }
 
   swift::SILType getSILResultType() const {

include/swift/SIL/SILFunctionConventions.h

@@ -409,7 +409,6 @@ class SILFunctionConventions {
   /// Return the SIL argument convention of apply/entry argument at
   /// the given argument index.
   SILArgumentConvention getSILArgumentConvention(unsigned index) const;
-  // See SILArgument.h.
 
   /// Return the SIL type of the apply/entry argument at the given index.
   SILType getSILArgumentType(unsigned index,

lib/SIL/IR/SILArgument.cpp

@@ -72,6 +72,42 @@ SILParameterInfo SILFunctionArgument::getKnownParameterInfo() const {
   return getFunction()->getConventions().getParamInfoForSILArg(getIndex());
 }
 
+SILArgumentConvention
+SILFunctionConventions::getSILArgumentConvention(unsigned index) const {
+  assert(index < getNumSILArguments());
+
+  // If the argument is a parameter, index into the parameters.
+  if (index >= getNumIndirectSILResults()) {
+    auto param = funcTy->getParameters()[index - getNumIndirectSILResults()];
+    return SILArgumentConvention(param.getConvention());
+  }
+
+  // If it's an indirect result, it could be either Pack_Out or
+  // Indirect_Out.
+
+  // Handle the common case of a function with no pack results.
+  if (funcTy->getNumPackResults() == 0) {
+    assert(silConv.loweredAddresses);
+    return SILArgumentConvention::Indirect_Out;
+  }
+
+  // Otherwise, we need to index into the indirect results to figure out
+  // whether the result is a pack or not, and unfortunately that is not a
+  // linear algorithm.
+  for (auto result : getIndirectSILResults()) {
+    if (index == 0) {
+      if (result.getConvention() == ResultConvention::Indirect) {
+        assert(silConv.loweredAddresses);
+        return SILArgumentConvention::Indirect_Out;
+      } else {
+        assert(result.getConvention() == ResultConvention::Pack);
+        return SILArgumentConvention::Pack_Out;
+      }
+    }
+    index--;
+  }
+  llvm_unreachable("mismatch with getNumIndirectSILResults()?");
+}
 
 //===----------------------------------------------------------------------===//
 //                              SILBlockArgument