Add a new parameter convention @in_cxx for non-trivial C++ classes that are passed indirectly and destructed by the caller (#73019)

This corresponds to the parameter-passing convention of the Itanium C++
ABI, in which the argument is passed indirectly and possibly modified,
but not destroyed, by the callee.

@in_cxx is handled the same way as @in in callers and @in_guaranteed in
callees. OwnershipModelEliminator emits the call to destroy_addr that is
needed to destroy the argument in the caller.

rdar://122707697

Author: ahatanaka

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ComputeSideEffects.swift

@@ -287,6 +287,8 @@ private struct CollectedEffects {
   private mutating func addEffects<Arguments: Sequence>(ofFunctions callees: FunctionArray?,
                                                         withArguments arguments: Arguments)
                                    where Arguments.Element == (calleeArgumentIndex: Int, callerArgument: Value) {
+    // The argument summary for @in_cxx is insufficient in OSSA because the function body does not contain the
+    // destroy. But the call is still effectively a release from the caller's perspective.
     guard let callees = callees else {
       // We don't know which function(s) are called.
       globalEffects = .worstEffects

SwiftCompilerSources/Sources/SIL/Argument.swift

@@ -352,6 +352,12 @@ public enum ArgumentConvention : CustomStringConvertible {
   /// convention used by mutable captures in @noescape closures.
   case indirectInoutAliasable
 
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory. The callee may modify, but does not destroy the
+  /// object. This corresponds to the parameter-passing convention of the
+  /// Itanium C++ ABI, which is used ubiquitously on non-Windows targets.
+  case indirectInCXX
+
   /// This argument represents an indirect return value address. The callee stores
   /// the returned value to this argument. At the time when the function is called,
   /// the memory location referenced by the argument is uninitialized.
@@ -407,8 +413,9 @@ public enum ArgumentConvention : CustomStringConvertible {
   public var isIndirect: Bool {
     switch self {
     case .indirectIn, .indirectInGuaranteed,
-         .indirectInout, .indirectInoutAliasable, .indirectOut,
-         .packOut, .packInout, .packOwned, .packGuaranteed:
+         .indirectInout, .indirectInoutAliasable, .indirectInCXX,
+         .indirectOut, .packOut, .packInout, .packOwned,
+         .packGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed:
       return false
@@ -417,11 +424,12 @@ public enum ArgumentConvention : CustomStringConvertible {
 
   public var isIndirectIn: Bool {
     switch self {
-    case .indirectIn, .indirectInGuaranteed,
+    case .indirectIn, .indirectInGuaranteed, .indirectInCXX,
          .packOwned, .packGuaranteed:
       return true
     case .directOwned, .directUnowned, .directGuaranteed,
-         .indirectInout, .indirectInoutAliasable, .indirectOut,
+         .indirectInout, .indirectInoutAliasable,
+         .indirectOut,
          .packOut, .packInout:
       return false
     }
@@ -433,7 +441,7 @@ public enum ArgumentConvention : CustomStringConvertible {
       return true
     case .indirectInGuaranteed, .directGuaranteed, .packGuaranteed,
          .indirectIn, .directOwned, .directUnowned,
-         .indirectInout, .indirectInoutAliasable,
+         .indirectInout, .indirectInoutAliasable, .indirectInCXX,
          .packInout, .packOwned:
       return false
     }
@@ -444,15 +452,15 @@ public enum ArgumentConvention : CustomStringConvertible {
     case .indirectInGuaranteed, .directGuaranteed, .packGuaranteed:
       return true
     case .indirectIn, .directOwned, .directUnowned,
-         .indirectInout, .indirectInoutAliasable, .indirectOut,
-         .packOut, .packInout, .packOwned:
+         .indirectInout, .indirectInoutAliasable, .indirectInCXX,
+         .indirectOut, .packOut, .packInout, .packOwned:
       return false
     }
   }
 
   public var isConsumed: Bool {
     switch self {
-    case .indirectIn, .directOwned, .packOwned:
+    case .indirectIn, .indirectInCXX, .directOwned, .packOwned:
       return true
     case .indirectInGuaranteed, .directGuaranteed, .packGuaranteed,
           .indirectInout, .indirectInoutAliasable, .indirectOut,
@@ -467,6 +475,7 @@ public enum ArgumentConvention : CustomStringConvertible {
          .indirectOut,
          .indirectInGuaranteed,
          .indirectInout,
+         .indirectInCXX,
          .packOut,
          .packInout,
          .packOwned,
@@ -491,6 +500,7 @@ public enum ArgumentConvention : CustomStringConvertible {
     case .indirectIn,
          .indirectOut,
          .indirectInGuaranteed,
+         .indirectInCXX,
          .directUnowned,
          .directGuaranteed,
          .directOwned,
@@ -511,6 +521,8 @@ public enum ArgumentConvention : CustomStringConvertible {
       return "indirectInout"
     case .indirectInoutAliasable:
       return "indirectInoutAliasable"
+    case .indirectInCXX:
+      return "indirectInCXX"
     case .indirectOut:
       return "indirectOut"
     case .directOwned:
@@ -545,6 +557,7 @@ extension BridgedArgumentConvention {
       case .Indirect_In_Guaranteed:  return .indirectInGuaranteed
       case .Indirect_Inout:          return .indirectInout
       case .Indirect_InoutAliasable: return .indirectInoutAliasable
+      case .Indirect_In_CXX:         return .indirectInCXX
       case .Indirect_Out:            return .indirectOut
       case .Direct_Owned:            return .directOwned
       case .Direct_Unowned:          return .directUnowned
@@ -566,6 +579,7 @@ extension ArgumentConvention {
       case .indirectInGuaranteed:   return .Indirect_In_Guaranteed
       case .indirectInout:          return .Indirect_Inout
       case .indirectInoutAliasable: return .Indirect_InoutAliasable
+      case .indirectInCXX:          return .Indirect_In_CXX
       case .indirectOut:            return .Indirect_Out
       case .directOwned:            return .Direct_Owned
       case .directUnowned:          return .Direct_Unowned

SwiftCompilerSources/Sources/SIL/Effects.swift

@@ -561,7 +561,7 @@ public struct SideEffects : CustomStringConvertible, NoReflectionChildren {
           result.memory = SideEffects.Memory()
         }
 
-      case .indirectInout, .indirectInoutAliasable:
+      case .indirectInout, .indirectInoutAliasable, .indirectInCXX:
         break
       }
       return result

SwiftCompilerSources/Sources/SIL/FunctionConvention.swift

@@ -171,7 +171,7 @@ public struct ParameterInfo : CustomStringConvertible {
     switch convention {
     case .indirectIn, .indirectInGuaranteed:
       return hasLoweredAddresses || type.isOpenedExistentialWithError()
-    case .indirectInout, .indirectInoutAliasable:
+    case .indirectInout, .indirectInoutAliasable, .indirectInCXX:
       return true
     case .directOwned, .directUnowned, .directGuaranteed:
       return false

docs/ABI/Mangling.rst

@@ -867,6 +867,7 @@ mangled in to disambiguate.
   PARAM-CONVENTION ::= 'l'                   // indirect inout
   PARAM-CONVENTION ::= 'b'                   // indirect inout aliasable
   PARAM-CONVENTION ::= 'n'                   // indirect in guaranteed
+  PARAM-CONVENTION ::= 'X'                   // indirect in C++
   PARAM-CONVENTION ::= 'x'                   // direct owned
   PARAM-CONVENTION ::= 'y'                   // direct unowned
   PARAM-CONVENTION ::= 'g'                   // direct guaranteed

include/swift/AST/TypeAttr.def

@@ -82,6 +82,7 @@ SIMPLE_SIL_TYPE_ATTR(in, In)
 SIMPLE_SIL_TYPE_ATTR(inout, Inout)
 SIMPLE_SIL_TYPE_ATTR(inout_aliasable, InoutAliasable)
 SIMPLE_SIL_TYPE_ATTR(in_guaranteed, InGuaranteed)
+SIMPLE_SIL_TYPE_ATTR(in_cxx, InCXX)
 SIMPLE_SIL_TYPE_ATTR(in_constant, InConstant)
 SIMPLE_SIL_TYPE_ATTR(pack_owned, PackOwned)
 SIMPLE_SIL_TYPE_ATTR(pack_guaranteed, PackGuaranteed)

include/swift/AST/Types.h

@@ -4068,6 +4068,12 @@ enum class ParameterConvention : uint8_t {
   /// convention used by mutable captures in @noescape closures.
   Indirect_InoutAliasable,
 
+  /// This argument is passed indirectly, i.e. by directly passing the address
+  /// of an object in memory. The callee may modify, but does not destroy the
+  /// object. This corresponds to the parameter-passing convention of the
+  /// Itanium C++ ABI, which is used ubiquitously on non-Windows targets.
+  Indirect_In_CXX,
+
   /// This argument is passed directly.  Its type is non-trivial, and the callee
   /// is responsible for destroying it.
   Direct_Owned,
@@ -4108,6 +4114,7 @@ inline bool isIndirectFormalParameter(ParameterConvention conv) {
   case ParameterConvention::Indirect_In:
   case ParameterConvention::Indirect_Inout:
   case ParameterConvention::Indirect_InoutAliasable:
+  case ParameterConvention::Indirect_In_CXX:
   case ParameterConvention::Indirect_In_Guaranteed:
     return true;
 
@@ -4129,7 +4136,8 @@ bool isConsumedParameter(ParameterConvention conv) {
   case ParameterConvention::Direct_Owned:
   case ParameterConvention::Pack_Owned:
     return true;
-
+  case ParameterConvention::Indirect_In_CXX:
+    return !InCallee;
   case ParameterConvention::Indirect_Inout:
   case ParameterConvention::Indirect_InoutAliasable:
   case ParameterConvention::Direct_Unowned:
@@ -4160,7 +4168,8 @@ bool isGuaranteedParameter(ParameterConvention conv) {
   case ParameterConvention::Indirect_In_Guaranteed:
   case ParameterConvention::Pack_Guaranteed:
     return true;
-
+  case ParameterConvention::Indirect_In_CXX:
+    return InCallee;
   case ParameterConvention::Indirect_Inout:
   case ParameterConvention::Indirect_InoutAliasable:
   case ParameterConvention::Indirect_In:
@@ -4185,6 +4194,7 @@ inline bool isMutatingParameter(ParameterConvention conv) {
   switch (conv) {
   case ParameterConvention::Indirect_Inout:
   case ParameterConvention::Indirect_InoutAliasable:
+  case ParameterConvention::Indirect_In_CXX:
   case ParameterConvention::Pack_Inout:
     return true;
 
@@ -4211,6 +4221,7 @@ inline bool isPackParameter(ParameterConvention conv) {
   case ParameterConvention::Indirect_In_Guaranteed:
   case ParameterConvention::Indirect_Inout:
   case ParameterConvention::Indirect_InoutAliasable:
+  case ParameterConvention::Indirect_In_CXX:
   case ParameterConvention::Indirect_In:
   case ParameterConvention::Direct_Guaranteed:
   case ParameterConvention::Direct_Unowned:
@@ -4291,6 +4302,10 @@ class SILParameterInfo {
     return getConvention() == ParameterConvention::Indirect_In;
   }
 
+  bool isIndirectInCXX() const {
+    return getConvention() == ParameterConvention::Indirect_In_CXX;
+  }
+
   bool isIndirectInOut() const {
     return getConvention() == ParameterConvention::Indirect_Inout;
   }

include/swift/SIL/ApplySite.h

@@ -412,6 +412,7 @@ class ApplySite {
                               : SILArgumentConvention::Direct_Owned;
     case SILArgumentConvention::Indirect_In:
     case SILArgumentConvention::Indirect_In_Guaranteed:
+    case SILArgumentConvention::Indirect_In_CXX:
       return pai->isOnStack() ? SILArgumentConvention::Indirect_In_Guaranteed
                               : SILArgumentConvention::Indirect_In;
     case SILArgumentConvention::Pack_Guaranteed:

include/swift/SIL/SILArgumentConvention.h

@@ -28,6 +28,7 @@ struct SILArgumentConvention {
     Indirect_In_Guaranteed,
     Indirect_Inout,
     Indirect_InoutAliasable,
+    Indirect_In_CXX,
     Indirect_Out,
     Direct_Owned,
     Direct_Unowned,
@@ -55,6 +56,9 @@ struct SILArgumentConvention {
     case ParameterConvention::Indirect_In_Guaranteed:
       Value = SILArgumentConvention::Indirect_In_Guaranteed;
       return;
+    case ParameterConvention::Indirect_In_CXX:
+      Value = SILArgumentConvention::Indirect_In_CXX;
+      return;
     case ParameterConvention::Direct_Unowned:
       Value = SILArgumentConvention::Direct_Unowned;
       return;
@@ -92,6 +96,7 @@ struct SILArgumentConvention {
       case SILArgumentConvention::Indirect_In_Guaranteed:
       case SILArgumentConvention::Indirect_In:
       case SILArgumentConvention::Indirect_Out:
+      case SILArgumentConvention::Indirect_In_CXX:
       case SILArgumentConvention::Direct_Unowned:
       case SILArgumentConvention::Direct_Owned:
       case SILArgumentConvention::Direct_Guaranteed:
@@ -110,6 +115,8 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Direct_Owned:
     case SILArgumentConvention::Pack_Owned:
       return true;
+    case SILArgumentConvention::Indirect_In_CXX:
+      return !InCallee;
     case SILArgumentConvention::Indirect_In_Guaranteed:
     case SILArgumentConvention::Direct_Guaranteed:
     case SILArgumentConvention::Indirect_Inout:
@@ -135,6 +142,8 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Direct_Guaranteed:
     case SILArgumentConvention::Pack_Guaranteed:
       return true;
+    case SILArgumentConvention::Indirect_In_CXX:
+      return InCallee;
     case SILArgumentConvention::Indirect_Inout:
     case SILArgumentConvention::Indirect_In:
     case SILArgumentConvention::Indirect_Out:
@@ -164,6 +173,7 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Indirect_Out:
     case SILArgumentConvention::Indirect_In_Guaranteed:
     case SILArgumentConvention::Indirect_Inout:
+    case SILArgumentConvention::Indirect_In_CXX:
       return true;
 
     case SILArgumentConvention::Indirect_InoutAliasable:
@@ -190,6 +200,7 @@ struct SILArgumentConvention {
     case SILArgumentConvention::Indirect_In_Guaranteed:
     case SILArgumentConvention::Indirect_Inout:
     case SILArgumentConvention::Indirect_InoutAliasable:
+    case SILArgumentConvention::Indirect_In_CXX:
     case SILArgumentConvention::Direct_Unowned:
     case SILArgumentConvention::Direct_Guaranteed:
     case SILArgumentConvention::Direct_Owned:

include/swift/SIL/SILBridging.h

@@ -136,6 +136,7 @@ enum class BridgedArgumentConvention {
   Indirect_In_Guaranteed,
   Indirect_Inout,
   Indirect_InoutAliasable,
+  Indirect_In_CXX,
   Indirect_Out,
   Direct_Owned,
   Direct_Unowned,
@@ -153,6 +154,7 @@ inline swift::ParameterConvention getParameterConvention(BridgedArgumentConventi
     case BridgedArgumentConvention::Indirect_In_Guaranteed:  return swift::ParameterConvention::Indirect_In_Guaranteed;
     case BridgedArgumentConvention::Indirect_Inout:          return swift::ParameterConvention::Indirect_Inout;
     case BridgedArgumentConvention::Indirect_InoutAliasable: return swift::ParameterConvention::Indirect_InoutAliasable;
+    case BridgedArgumentConvention::Indirect_In_CXX:         return swift::ParameterConvention::Indirect_In_CXX;
     case BridgedArgumentConvention::Indirect_Out:            break;
     case BridgedArgumentConvention::Direct_Owned:            return swift::ParameterConvention::Direct_Owned;
     case BridgedArgumentConvention::Direct_Unowned:          return swift::ParameterConvention::Direct_Unowned;
@@ -171,6 +173,7 @@ inline BridgedArgumentConvention getArgumentConvention(swift::ParameterConventio
     case swift::ParameterConvention::Indirect_In_Guaranteed:   return BridgedArgumentConvention::Indirect_In_Guaranteed;
     case swift::ParameterConvention::Indirect_Inout:           return BridgedArgumentConvention::Indirect_Inout;
     case swift::ParameterConvention::Indirect_InoutAliasable:  return BridgedArgumentConvention::Indirect_InoutAliasable;
+    case swift::ParameterConvention::Indirect_In_CXX:          return BridgedArgumentConvention::Indirect_In_CXX;
     case swift::ParameterConvention::Direct_Owned:             return BridgedArgumentConvention::Direct_Owned;
     case swift::ParameterConvention::Direct_Unowned:           return BridgedArgumentConvention::Direct_Unowned;
     case swift::ParameterConvention::Direct_Guaranteed:        return BridgedArgumentConvention::Direct_Guaranteed;