[outliner] Add support for passing bridging args as guaranteed if we do not find a release.

Author: gottesmm

lib/Demangling/Demangler.cpp

@@ -2339,7 +2339,7 @@ std::string Demangler::demangleBridgedMethodParams() {
 
   while (!nextIf('_')) {
     auto c = nextChar();
-    if (c != 'n' && c != 'b')
+    if (c != 'n' && c != 'b' && c != 'g')
       return std::string();
     Str.push_back(c);
   }

lib/SILOptimizer/Transforms/Outliner.cpp

@@ -18,16 +18,17 @@
 #include "swift/AST/Types.h"
 #include "swift/Demangling/Demangler.h"
 #include "swift/Demangling/ManglingMacros.h"
+#include "swift/SIL/ApplySite.h"
 #include "swift/SIL/DebugUtils.h"
 #include "swift/SIL/DynamicCasts.h"
 #include "swift/SIL/SILArgument.h"
 #include "swift/SIL/SILBuilder.h"
 #include "swift/SIL/SILFunction.h"
-#include "swift/SILOptimizer/Utils/SILOptFunctionBuilder.h"
 #include "swift/SIL/SILInstruction.h"
 #include "swift/SIL/SILModule.h"
 #include "swift/SILOptimizer/PassManager/Passes.h"
 #include "swift/SILOptimizer/PassManager/Transforms.h"
+#include "swift/SILOptimizer/Utils/SILOptFunctionBuilder.h"
 #include "llvm/ADT/BitVector.h"
 #include "llvm/Support/CommandLine.h"
 #include "llvm/Support/raw_ostream.h"
@@ -50,20 +51,23 @@ class OutlinerMangler : public Mangle::ASTMangler {
   };
 
   llvm::BitVector *IsParameterBridged;
+  llvm::BitVector *IsParameterGuaranteed;
   SILDeclRef MethodDecl;
   MethodKind Kind;
   bool IsReturnBridged;
 
 public:
   /// Create an mangler for an outlined bridged method.
   OutlinerMangler(SILDeclRef Method, llvm::BitVector *ParameterBridged,
-                  bool ReturnBridged)
-      : IsParameterBridged(ParameterBridged), MethodDecl(Method),
+                  llvm::BitVector *IsParameterGuaranteed, bool ReturnBridged)
+      : IsParameterBridged(ParameterBridged),
+        IsParameterGuaranteed(IsParameterGuaranteed), MethodDecl(Method),
         Kind(BridgedMethod), IsReturnBridged(ReturnBridged) {}
 
   /// Create an mangler for an outlined bridged property.
   OutlinerMangler(SILDeclRef Method, bool IsAddress)
-      : IsParameterBridged(nullptr), MethodDecl(Method),
+      : IsParameterBridged(nullptr), IsParameterGuaranteed(nullptr),
+        MethodDecl(Method),
         Kind(IsAddress ? BridgedPropertyAddress : BridgedProperty),
         IsReturnBridged(true) {}
 
@@ -93,9 +97,14 @@ std::string OutlinerMangler::mangle() {
   llvm::raw_svector_ostream Out(Buffer);
 
   Out << getMethodKindMangling();
-  if (IsParameterBridged)
-    for (unsigned Idx = 0,  E = IsParameterBridged->size(); Idx != E; ++Idx)
+  if (IsParameterBridged) {
+    for (unsigned Idx = 0, E = IsParameterBridged->size(); Idx != E; ++Idx) {
       Out << (IsParameterBridged->test(Idx) ? 'b' : 'n');
+      // NOTE: We must keep owned as having nothing here to preserve ABI since
+      // mangling is part of ABI.
+      Out << (IsParameterGuaranteed->test(Idx) ? "g" : "");
+    }
+  }
   Out << (IsReturnBridged ? 'b' : 'n');
   Out << '_';
 
@@ -643,7 +652,10 @@ bool BridgedProperty::matchInstSequence(SILBasicBlock::iterator It) {
 
 
 namespace {
+
 /// Match a bridged argument.
+///
+///
 /// %15 = function_ref @$SSS10FoundationE19_bridgeToObjectiveCSo8NSStringCyF
 /// %16 = apply %15(%14) :
 ///         $@convention(method) (@guaranteed String) -> @owned NSString
@@ -652,20 +664,26 @@ namespace {
 ///
 /// apply %objcMethod(%17, ...) : $@convention(objc_method) (Optional<NSString> ...) ->
 /// release_value %17 : $Optional<NSString>
+///
+/// NOTE: If release_value %14 is found, our outlined function will have an
+/// owned convention for self. Otherwise, if we do not find it, we will have a
+/// guaranteed one.
 class BridgedArgument {
 public:
   FunctionRefInst *BridgeFun;
   ApplyInst *BridgeCall;
   EnumInst *OptionalResult;
+  SILValue BridgedValue;
   ReleaseValueInst *ReleaseAfterBridge;
   ReleaseValueInst *ReleaseArgAfterCall;
   unsigned Idx = 0;
 
   // Matched bridged argument.
   BridgedArgument(unsigned Idx, FunctionRefInst *F, ApplyInst *A, EnumInst *E,
                   ReleaseValueInst *R0, ReleaseValueInst *R1)
-      : BridgeFun(F), BridgeCall(A), OptionalResult(E), ReleaseAfterBridge(R0),
-        ReleaseArgAfterCall(R1), Idx(Idx) {}
+      : BridgeFun(F), BridgeCall(A), OptionalResult(E),
+        BridgedValue(FullApplySite(A).getSelfArgument()),
+        ReleaseAfterBridge(R0), ReleaseArgAfterCall(R1), Idx(Idx) {}
 
   /// Invalid argument constructor.
   BridgedArgument()
@@ -675,7 +693,14 @@ class BridgedArgument {
   static BridgedArgument match(unsigned ArgIdx, SILValue Arg, ApplyInst *AI);
 
   operator bool() const { return BridgeFun != nullptr; }
-  SILValue bridgedValue() { return ReleaseAfterBridge->getOperand(); }
+  SILValue bridgedValue() { return BridgedValue; }
+
+  bool isGuaranteed() const { return ReleaseAfterBridge == nullptr; }
+  ParameterConvention getConvention() const {
+    if (isGuaranteed())
+      return ParameterConvention::Direct_Guaranteed;
+    return ParameterConvention::Direct_Owned;
+  }
 
   void eraseFromParent();
 
@@ -697,14 +722,17 @@ void BridgedArgument::transferTo(SILValue BridgedValue,
   DestBB->moveTo(SILBasicBlock::iterator(BridgedCall), BridgeCall);
   BridgeCall->setArgument(0, BridgedValue);
   DestBB->moveTo(SILBasicBlock::iterator(BridgedCall), OptionalResult);
-  DestBB->moveTo(SILBasicBlock::iterator(BridgedCall), ReleaseAfterBridge);
-  ReleaseAfterBridge->setOperand(BridgedValue);
+  if (ReleaseAfterBridge) {
+    DestBB->moveTo(SILBasicBlock::iterator(BridgedCall), ReleaseAfterBridge);
+    ReleaseAfterBridge->setOperand(BridgedValue);
+  }
   auto AfterCall = std::next(SILBasicBlock::iterator(BridgedCall));
   DestBB->moveTo(SILBasicBlock::iterator(AfterCall), ReleaseArgAfterCall);
 }
 
 void BridgedArgument::eraseFromParent() {
-  ReleaseAfterBridge->eraseFromParent();
+  if (ReleaseAfterBridge)
+    ReleaseAfterBridge->eraseFromParent();
   ReleaseArgAfterCall->eraseFromParent();
   OptionalResult->eraseFromParent();
   BridgeCall->eraseFromParent();
@@ -740,9 +768,12 @@ BridgedArgument BridgedArgument::match(unsigned ArgIdx, SILValue Arg,
   auto Next = std::next(SILBasicBlock::iterator(Enum));
   if (Next == Enum->getParent()->end())
     return BridgedArgument();
+
+  // Make sure that if we have a bridged value release that it is on the bridged
+  // value.
   auto *BridgedValueRelease =
       dyn_cast<ReleaseValueInst>(std::next(SILBasicBlock::iterator(Enum)));
-  if (!BridgedValueRelease || BridgedValueRelease->getOperand() != BridgedValue)
+  if (BridgedValueRelease && BridgedValueRelease->getOperand() != BridgedValue)
     return BridgedArgument();
 
   if (SILBasicBlock::iterator(BridgeCall) == BridgeCall->getParent()->begin())
@@ -885,6 +916,7 @@ class ObjCMethodCall : public OutlinePattern {
   SmallVector<BridgedArgument, 4> BridgedArguments;
   std::string OutlinedName;
   llvm::BitVector IsBridgedArgument;
+  llvm::BitVector IsGuaranteedArgument;
   BridgedReturn BridgedReturn;
 public:
   bool matchInstSequence(SILBasicBlock::iterator I) override;
@@ -913,6 +945,7 @@ void ObjCMethodCall::clearState() {
   BridgedArguments.clear();
   OutlinedName.clear();
   IsBridgedArgument.clear();
+  IsGuaranteedArgument.clear();
 }
 
 std::pair<SILFunction *, SILBasicBlock::iterator>
@@ -1018,7 +1051,7 @@ ObjCMethodCall::outline(SILModule &M) {
 std::string ObjCMethodCall::getOutlinedFunctionName() {
   if (OutlinedName.empty()) {
     OutlinerMangler Mangler(ObjCMethod->getMember(), &IsBridgedArgument,
-                            BridgedReturn);
+                            &IsGuaranteedArgument, BridgedReturn);
     OutlinedName = Mangler.mangle();
   }
   return OutlinedName;
@@ -1046,6 +1079,7 @@ bool ObjCMethodCall::matchInstSequence(SILBasicBlock::iterator I) {
   // Collect bridged parameters.
   unsigned Idx = 0;
   IsBridgedArgument.resize(BridgedCall->getNumArguments(), false);
+  IsGuaranteedArgument.resize(BridgedCall->getNumArguments(), false);
   for (auto &Param : BridgedCall->getArgumentOperands()) {
     unsigned CurIdx = Idx++;
 
@@ -1066,6 +1100,8 @@ bool ObjCMethodCall::matchInstSequence(SILBasicBlock::iterator I) {
 
     BridgedArguments.push_back(BridgedArg);
     IsBridgedArgument.set(CurIdx);
+    if (BridgedArg.isGuaranteed())
+      IsGuaranteedArgument.set(CurIdx);
   }
 
   // Try to match a bridged return value.
@@ -1097,11 +1133,12 @@ CanSILFunctionType ObjCMethodCall::getOutlinedFunctionType(SILModule &M) {
     // Either use the bridged type passing it @owned.
     if (BridgedArgIdx < BridgedArguments.size() &&
         BridgedArguments[BridgedArgIdx].Idx == OrigSigIdx) {
+      auto convention = BridgedArguments[BridgedArgIdx].getConvention();
       Parameters.push_back(SILParameterInfo(BridgedArguments[BridgedArgIdx]
                                                 .bridgedValue()
                                                 ->getType()
                                                 .getASTType(),
-                                            ParameterConvention::Direct_Owned));
+                                            convention));
       ++BridgedArgIdx;
     } else {
       // Otherwise, use the original type convention.

test/Demangle/Inputs/manglings.txt

@@ -293,6 +293,7 @@ _T03nix6testitSaySiGyFTv_ ---> outlined variable #0 of nix.testit() -> [Swift.In
 _T03nix6testitSaySiGyFTv0_ ---> outlined variable #1 of nix.testit() -> [Swift.Int]
 _T0So11UITextFieldC4textSSSgvgToTepb_ ---> outlined bridged method (pb) of @objc __C.UITextField.text.getter : Swift.String?
 _T0So11UITextFieldC4textSSSgvgToTeab_ ---> outlined bridged method (ab) of @objc __C.UITextField.text.getter : Swift.String?
+$sSo5GizmoC11doSomethingyypSgSaySSGSgFToTembgnn_ ---> outlined bridged method (mbgnn) of @objc __C.Gizmo.doSomething([Swift.String]?) -> Any?
 _T04test1SVyxGAA1RA2A1ZRzAA1Y2ZZRpzl1A_AhaGPWT ---> {C} associated type witness table accessor for A.ZZ : test.Y in <A where A: test.Z, A.ZZ: test.Y> test.S<A> : test.R in test
 _T0s24_UnicodeScalarExceptions33_0E4228093681F6920F0AB2E48B4F1C69LLVACycfC ---> {T:_T0s24_UnicodeScalarExceptions33_0E4228093681F6920F0AB2E48B4F1C69LLVACycfc} Swift.(_UnicodeScalarExceptions in _0E4228093681F6920F0AB2E48B4F1C69).init() -> Swift.(_UnicodeScalarExceptions in _0E4228093681F6920F0AB2E48B4F1C69)
 _T0D ---> _T0D