Merge branch 'apple:main' into main

Author: Genaro-Chris

SwiftCompilerSources/Sources/Optimizer/FunctionPasses/ObjectOutliner.swift

@@ -41,7 +41,6 @@ import SIL
 ///
 let objectOutliner = FunctionPass(name: "object-outliner") {
   (function: Function, context: FunctionPassContext) in
-
   for inst in function.instructions {
     if let ari = inst as? AllocRefInstBase {
       if let globalValue = optimizeObjectAllocation(allocRef: ari, context) {
@@ -85,6 +84,10 @@ private func findEndCOWMutation(of object: Value) -> EndCOWMutationInst? {
       if let ecm = findEndCOWMutation(of: uci) {
         return ecm
       }
+    case let urci as UncheckedRefCastInst:
+      if let ecm = findEndCOWMutation(of: urci) {
+        return ecm
+      }
     case let mv as MoveValueInst:
       if let ecm = findEndCOWMutation(of: mv) {
         return ecm
@@ -147,7 +150,7 @@ private func findInitStores(of object: Value,
         return false
       }
     default:
-      if !isValidUseOfObject(use.instruction) {
+      if !isValidUseOfObject(use) {
         return false
       }
     }
@@ -174,6 +177,18 @@ private func findStores(toTailAddress tailAddr: Value, tailElementIndex: Int, st
       if !findStores(inUsesOf: tea, index: tailElementIndex * numTupleElements + tupleIdx, stores: &stores) {
         return false
       }
+    case let atp as AddressToPointerInst:
+      if !findStores(toTailAddress: atp, tailElementIndex: tailElementIndex, stores: &stores) {
+        return false
+      }
+    case let mdi as MarkDependenceInst:
+      if !findStores(toTailAddress: mdi, tailElementIndex: tailElementIndex, stores: &stores) {
+        return false
+      }
+    case let pta as PointerToAddressInst:
+      if !findStores(toTailAddress: pta, tailElementIndex: tailElementIndex, stores: &stores) {
+        return false
+      }
     case let store as StoreInst:
       if store.source.type.isTuple {
         // This kind of SIL is never generated because tuples are stored with separated stores to tuple_element_addr.
@@ -184,7 +199,7 @@ private func findStores(toTailAddress tailAddr: Value, tailElementIndex: Int, st
         return false
       }
     default:
-      if !isValidUseOfObject(use.instruction) {
+      if !isValidUseOfObject(use) {
         return false
       }
     }
@@ -198,7 +213,7 @@ private func findStores(inUsesOf address: Value, index: Int, stores: inout [Stor
       if !handleStore(store, index: index, stores: &stores) {
         return false
       }
-    } else if !isValidUseOfObject(use.instruction) {
+    } else if !isValidUseOfObject(use) {
       return false
     }
   }
@@ -215,7 +230,8 @@ private func handleStore(_ store: StoreInst, index: Int, stores: inout [StoreIns
   return false
 }
 
-private func isValidUseOfObject(_ inst: Instruction) -> Bool {
+private func isValidUseOfObject(_ use: Operand) -> Bool {
+  let inst = use.instruction
   switch inst {
   case is DebugValueInst,
        is LoadInst,
@@ -227,6 +243,17 @@ private func isValidUseOfObject(_ inst: Instruction) -> Bool {
        is EndCOWMutationInst:
     return true
 
+  case let mdi as MarkDependenceInst:
+    if (use == mdi.baseOperand) {
+      return true;
+    }
+    for mdiUse in mdi.uses {
+      if !isValidUseOfObject(mdiUse) {
+        return false
+      }
+    }
+    return true
+
   case is StructElementAddrInst,
        is AddressToPointerInst,
        is StructInst,
@@ -238,9 +265,12 @@ private func isValidUseOfObject(_ inst: Instruction) -> Bool {
        is UpcastInst,
        is BeginDeallocRefInst,
        is RefTailAddrInst,
-       is RefElementAddrInst:
-    for use in (inst as! SingleValueInstruction).uses {
-      if !isValidUseOfObject(use.instruction) {
+       is RefElementAddrInst,
+       is StructInst,
+       is PointerToAddressInst,
+       is IndexAddrInst:
+    for instUse in (inst as! SingleValueInstruction).uses {
+      if !isValidUseOfObject(instUse) {
         return false
       }
     }
@@ -342,6 +372,8 @@ private func rewriteUses(of startValue: Value, _ context: FunctionPassContext) {
       context.erase(instruction: endMutation)
     case let upCast as UpcastInst:
       worklist.pushIfNotVisited(usersOf: upCast)
+    case let urci as UncheckedRefCastInst:
+      worklist.pushIfNotVisited(usersOf: urci)
     case let moveValue as MoveValueInst:
       worklist.pushIfNotVisited(usersOf: moveValue)
     case is DeallocRefInst, is DeallocStackRefInst:

SwiftCompilerSources/Sources/SIL/Instruction.swift

@@ -1094,6 +1094,10 @@ final public class ThrowInst : TermInst, UnaryInstruction {
   public override var isFunctionExiting: Bool { true }
 }
 
+final public class ThrowAddrInst : TermInst {
+  public override var isFunctionExiting: Bool { true }
+}
+
 final public class YieldInst : TermInst {
 }
 

SwiftCompilerSources/Sources/SIL/Registration.swift

@@ -172,6 +172,7 @@ public func registerSILClasses() {
   register(UnreachableInst.self)
   register(ReturnInst.self)
   register(ThrowInst.self)
+  register(ThrowAddrInst.self)
   register(YieldInst.self)
   register(UnwindInst.self)
   register(TryApplyInst.self)

docs/SIL.rst

@@ -613,8 +613,8 @@ the caller.  A non-autoreleased ``apply`` of a function that is defined
 with an autoreleased result has the effect of performing an
 autorelease in the callee.
 
-- SIL function types may provide an optional error result, written by
-  placing ``@error`` on a result.  An error result is always
+- SIL function types may provide an optional direct error result, written by
+  placing ``@error`` on a result.  A direct error result is always
   implicitly ``@owned``.  Only functions with a native calling
   convention may have an error result.
 
@@ -8006,6 +8006,28 @@ the basic block argument will be the operand of the ``throw``.
 
 A function must not contain more than one ``throw`` instruction.
 
+throw_addr
+``````````
+::
+
+  sil-terminator ::= 'throw_addr'
+
+  throw_addr
+  // indirect error result must be initialized at this point
+
+Exits the current function and returns control to the calling
+function. The current function must have an indirect error result,
+and so the function must have been invoked with a ``try_apply``
+instruction. Control will resume in the error destination of
+that instruction.
+
+The function is responsible for initializing its error result
+before the ``throw_addr``. 
+
+``throw_addr`` does not retain or release any values.
+
+A function must not contain more than one ``throw_addr`` instruction.
+
 yield
 `````
 ::

include/swift/AST/ASTBridging.h

@@ -26,31 +26,73 @@
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
 namespace swift {
-  class DiagnosticArgument;
-  class DiagnosticEngine;
+class ASTContext;
+class DiagnosticArgument;
+class DiagnosticEngine;
 }
 
 //===----------------------------------------------------------------------===//
 // MARK: Identifier
 //===----------------------------------------------------------------------===//
 
-struct BridgedIdentifier {
-  const void *_Nullable raw;
+class BridgedIdentifier {
+public:
+  SWIFT_UNAVAILABLE("Use '.raw' instead")
+  const void *_Nullable Raw;
+
+  BridgedIdentifier() : Raw(nullptr) {}
+
+  SWIFT_NAME("init(raw:)")
+  BridgedIdentifier(const void *_Nullable raw) : Raw(raw) {}
+
+#ifdef USED_IN_CPP_SOURCE
+  BridgedIdentifier(swift::Identifier ident)
+      : Raw(ident.getAsOpaquePointer()) {}
+
+  swift::Identifier unbridged() const {
+    return swift::Identifier::getFromOpaquePointer(Raw);
+  }
+#endif
 };
 
+SWIFT_NAME("getter:BridgedIdentifier.raw(self:)")
+inline const void *_Nullable BridgedIdentifier_raw(BridgedIdentifier ident) {
+  return ident.Raw;
+}
+
 struct BridgedIdentifierAndSourceLoc {
-  BridgedIdentifier name;
-  BridgedSourceLoc nameLoc;
+  SWIFT_NAME("name")
+  BridgedIdentifier Name;
+
+  SWIFT_NAME("nameLoc")
+  BridgedSourceLoc NameLoc;
 };
 
 //===----------------------------------------------------------------------===//
 // MARK: ASTContext
 //===----------------------------------------------------------------------===//
 
-struct BridgedASTContext {
-  void *_Nonnull raw;
+class BridgedASTContext {
+  swift::ASTContext * _Nonnull Ctx;
+
+public:
+#ifdef USED_IN_CPP_SOURCE
+  SWIFT_UNAVAILABLE("Use init(raw:) instead")
+  BridgedASTContext(swift::ASTContext &ctx) : Ctx(&ctx) {}
+
+  SWIFT_UNAVAILABLE("Use '.raw' instead")
+  swift::ASTContext &unbridged() const { return *Ctx; }
+#endif
 };
 
+SWIFT_NAME("getter:BridgedASTContext.raw(self:)")
+BRIDGED_INLINE
+void * _Nonnull BridgedASTContext_raw(BridgedASTContext bridged);
+
+SWIFT_NAME("BridgedASTContext.init(raw:)")
+BRIDGED_INLINE
+BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr);
+
 SWIFT_NAME("BridgedASTContext.getIdentifier(self:_:)")
 BridgedIdentifier BridgedASTContext_getIdentifier(BridgedASTContext cContext,
                                                   BridgedStringRef cStr);
@@ -70,8 +112,11 @@ enum ENUM_EXTENSIBILITY_ATTR(open) ASTNodeKind : size_t {
 };
 
 struct BridgedASTNode {
-  void *_Nonnull ptr;
-  ASTNodeKind kind;
+  SWIFT_NAME("raw")
+  void *_Nonnull Raw;
+
+  SWIFT_NAME("kind")
+  ASTNodeKind Kind;
 };
 
 // Forward declare the underlying AST node type for each wrapper.
@@ -81,11 +126,12 @@ namespace swift {
 } // end namespace swift
 
 // Define the bridging wrappers for each AST node.
-#define AST_BRIDGING_WRAPPER(Name) BRIDGING_WRAPPER_NONNULL(Name)
+#define AST_BRIDGING_WRAPPER(Name) BRIDGING_WRAPPER_NONNULL(swift::Name, Name)
 #include "swift/AST/ASTBridgingWrappers.def"
 
 // For nullable nodes, also define a nullable variant.
-#define AST_BRIDGING_WRAPPER_NULLABLE(Name) BRIDGING_WRAPPER_NULLABLE(Name)
+#define AST_BRIDGING_WRAPPER_NULLABLE(Name)                                    \
+  BRIDGING_WRAPPER_NULLABLE(swift::Name, Name)
 #define AST_BRIDGING_WRAPPER_NONNULL(Name)
 #include "swift/AST/ASTBridgingWrappers.def"
 
@@ -150,7 +196,7 @@ class BridgedDiagnosticArgument {
   BridgedDiagnosticArgument(const swift::DiagnosticArgument &arg) {
     *reinterpret_cast<swift::DiagnosticArgument *>(&storage) = arg;
   }
-  const swift::DiagnosticArgument &get() const {
+  const swift::DiagnosticArgument &unbridged() const {
     return *reinterpret_cast<const swift::DiagnosticArgument *>(&storage);
   }
 #endif
@@ -167,7 +213,7 @@ class BridgedDiagnosticFixIt {
   BridgedDiagnosticFixIt(const swift::DiagnosticInfo::FixIt &fixit){
     *reinterpret_cast<swift::DiagnosticInfo::FixIt *>(&storage) = fixit;
   }
-  const swift::DiagnosticInfo::FixIt &get() const {
+  const swift::DiagnosticInfo::FixIt &unbridged() const {
     return *reinterpret_cast<const swift::DiagnosticInfo::FixIt *>(&storage);
   }
 #endif
@@ -184,8 +230,18 @@ enum ENUM_EXTENSIBILITY_ATTR(open) BridgedDiagnosticSeverity : size_t {
   BridgedNote,
 };
 
-struct BridgedDiagnostic {
-  void *_Nonnull raw;
+class BridgedDiagnostic {
+public:
+  struct Impl;
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  Impl *_Nonnull Raw;
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  BridgedDiagnostic(Impl *_Nonnull raw) : Raw(raw) {}
+
+  SWIFT_UNAVAILABLE("Unavailable in Swift")
+  Impl *_Nonnull unbridged() const { return Raw; }
 };
 
 // FIXME: Can we bridge InFlightDiagnostic?

include/swift/AST/ASTBridgingImpl.h

@@ -17,24 +17,36 @@
 
 SWIFT_BEGIN_NULLABILITY_ANNOTATIONS
 
+//===----------------------------------------------------------------------===//
+// MARK: BridgedASTContext
+//===----------------------------------------------------------------------===//
+
+void * _Nonnull BridgedASTContext_raw(BridgedASTContext bridged) {
+  return &bridged.unbridged();
+}
+
+BridgedASTContext BridgedASTContext_fromRaw(void * _Nonnull ptr) {
+  return *static_cast<swift::ASTContext *>(ptr);
+}
+
 //===----------------------------------------------------------------------===//
 // MARK: BridgedNominalTypeDecl
 //===----------------------------------------------------------------------===//
 
 BridgedStringRef BridgedNominalTypeDecl_getName(BridgedNominalTypeDecl decl) {
-  return decl.get()->getName().str();
+  return decl.unbridged()->getName().str();
 }
 
 bool BridgedNominalTypeDecl_isGlobalActor(BridgedNominalTypeDecl decl) {
-  return decl.get()->isGlobalActor();
+  return decl.unbridged()->isGlobalActor();
 }
 
 //===----------------------------------------------------------------------===//
 // MARK: BridgedVarDecl
 //===----------------------------------------------------------------------===//
 
 BridgedStringRef BridgedVarDecl_getUserFacingName(BridgedVarDecl decl) {
-  return decl.get()->getBaseName().userFacingName();
+  return decl.unbridged()->getBaseName().userFacingName();
 }
 
 SWIFT_END_NULLABILITY_ANNOTATIONS