Merge pull request #2360 from swiftwasm/main

[pull] swiftwasm from main

Author: pull[bot]

docs/ABI/Mangling.rst

@@ -207,6 +207,7 @@ types where the metadata itself has unknown layout.)
   global ::= global 'TD'                 // dynamic dispatch thunk
   global ::= global 'Td'                 // direct method reference thunk
   global ::= global 'TI'                 // implementation of a dynamic_replaceable function
+  global :== global 'Tu'                 // async function pointer of a function
   global ::= global 'TX'                 // function pointer of a dynamic_replaceable function
   global ::= entity entity 'TV'          // vtable override thunk, derived followed by base
   global ::= type label-list? 'D'        // type mangling for the debugger with label list for function types.
@@ -493,6 +494,7 @@ Types
   type ::= 'Bb'                              // Builtin.BridgeObject
   type ::= 'BB'                              // Builtin.UnsafeValueBuffer
   type ::= 'Bc'                              // Builtin.RawUnsafeContinuation
+  type ::= 'BD'                              // Builtin.DefaultActorStorage
   type ::= 'Bf' NATURAL '_'                  // Builtin.Float<n>
   type ::= 'Bi' NATURAL '_'                  // Builtin.Int<n>
   type ::= 'BI'                              // Builtin.IntLiteral

include/swift/AST/TypeNodes.def

@@ -110,6 +110,7 @@ ABSTRACT_TYPE(Builtin, Type)
   BUILTIN_TYPE(BuiltinNativeObject, BuiltinType)
   BUILTIN_TYPE(BuiltinBridgeObject, BuiltinType)
   BUILTIN_TYPE(BuiltinUnsafeValueBuffer, BuiltinType)
+  BUILTIN_TYPE(BuiltinDefaultActorStorage, BuiltinType)
   BUILTIN_TYPE(BuiltinVector, BuiltinType)
   TYPE_RANGE(Builtin, BuiltinInteger, BuiltinVector)
 TYPE(Tuple, Type)
@@ -185,6 +186,7 @@ SINGLETON_TYPE(RawUnsafeContinuation, BuiltinRawUnsafeContinuation)
 SINGLETON_TYPE(NativeObject, BuiltinNativeObject)
 SINGLETON_TYPE(BridgeObject, BuiltinBridgeObject)
 SINGLETON_TYPE(UnsafeValueBuffer, BuiltinUnsafeValueBuffer)
+SINGLETON_TYPE(DefaultActorStorage, BuiltinDefaultActorStorage)
 SINGLETON_TYPE(SILToken, SILToken)
 #undef SINGLETON_TYPE
 #endif

include/swift/AST/Types.h

@@ -1420,6 +1420,22 @@ class BuiltinJobType : public BuiltinType {
 };
 DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinJobType, BuiltinType);
 
+/// BuiltinDefaultActorStorageType - The type of the stored property
+/// that's added implicitly to default actors.  No C equivalent because
+/// the C types all include a heap-object header.  Similarly, this type
+/// generally does not appear in the AST/SIL around default actors;
+/// it's purely a convenience in IRGen.
+class BuiltinDefaultActorStorageType : public BuiltinType {
+  friend class ASTContext;
+  BuiltinDefaultActorStorageType(const ASTContext &C)
+    : BuiltinType(TypeKind::BuiltinDefaultActorStorage, C) {}
+public:
+  static bool classof(const TypeBase *T) {
+    return T->getKind() == TypeKind::BuiltinDefaultActorStorage;
+  }
+};
+DEFINE_EMPTY_CAN_TYPE_WRAPPER(BuiltinDefaultActorStorageType, BuiltinType);
+
 /// BuiltinNativeObjectType - The builtin opaque object-pointer type.
 /// Useful for keeping an object alive when it is otherwise being
 /// manipulated via an unsafe pointer type.

include/swift/Demangling/DemangleNodes.def

@@ -306,5 +306,8 @@ NODE(GlobalVariableOnceToken)
 NODE(GlobalVariableOnceDeclList)
 NODE(CanonicalPrespecializedGenericTypeCachingOnceToken)
 
+// Added in Swift 5.5
+NODE(AsyncFunctionPointer)
+
 #undef CONTEXT_NODE
 #undef NODE

include/swift/Reflection/Records.h

@@ -37,6 +37,9 @@ class FieldRecordFlags {
 
     // Is this a mutable `var` property?
     IsVar = 0x2,
+
+    // Is this an artificial field?
+    IsArtificial = 0x4,
   };
   int_type Data = 0;
 
@@ -49,6 +52,10 @@ class FieldRecordFlags {
     return (Data & IsVar) == IsVar;
   }
 
+  bool isArtificial() const {
+    return (Data & IsArtificial) == IsArtificial;
+  }
+
   void setIsIndirectCase(bool IndirectCase=true) {
     if (IndirectCase)
       Data |= IsIndirectCase;
@@ -63,6 +70,13 @@ class FieldRecordFlags {
       Data &= ~IsVar;
   }
 
+  void setIsArtificial(bool artificial=true) {
+    if (artificial)
+      Data |= IsArtificial;
+    else
+      Data &= ~IsArtificial;
+  }
+
   int_type getRawValue() const {
     return Data;
   }

include/swift/SIL/ApplySite.h

@@ -337,7 +337,7 @@ class ApplySite {
   }
 
   /// Return the SILArgumentConvention for the given applied argument operand.
-  SILArgumentConvention getArgumentConvention(Operand &oper) const {
+  SILArgumentConvention getArgumentConvention(const Operand &oper) const {
     unsigned calleeArgIdx =
         getCalleeArgIndexOfFirstAppliedArg() + getAppliedArgIndex(oper);
     return getSubstCalleeConv().getSILArgumentConvention(calleeArgIdx);
@@ -615,7 +615,8 @@ class FullApplySite : public ApplySite {
   /// Returns true if \p op is an operand that passes an indirect
   /// result argument to the apply site.
   bool isIndirectResultOperand(const Operand &op) const {
-    return getCalleeArgIndex(op) < getNumIndirectSILResults();
+    return isArgumentOperand(op)
+      && (getCalleeArgIndex(op) < getNumIndirectSILResults());
   }
 
   static FullApplySite getFromOpaqueValue(void *p) { return FullApplySite(p); }

include/swift/SIL/OwnershipUtils.h

@@ -32,29 +32,47 @@ class DeadEndBlocks;
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
 
-/// Is this an operand that can forward both owned and guaranteed ownership into
-/// one of the operand's owner instruction's result.
-bool isOwnershipForwardingUse(Operand *op);
-
-/// Is this an operand that can forward guaranteed ownership into one of the
-/// operand's owner instruction's result.
-bool isGuaranteedForwardingUse(Operand *op);
-
-/// Is this an operand that can forward owned ownership into one of the
-/// operand's owner instruction's result.
-bool isOwnedForwardingUse(Operand *use);
+/// Is the opcode that produces \p value capable of forwarding guaranteed
+/// values?
+///
+/// This may be true even if the current instance of the instruction is not a
+/// ForwardingBorrow. If true, then the operation may be trivially rewritten
+/// with Guaranteed ownership.
+bool canOpcodeForwardGuaranteedValues(SILValue value);
 
-/// Is this a value that is the result of an instruction that forwards
-/// guaranteed ownership from one of its operands.
-bool isGuaranteedForwardingValue(SILValue value);
+/// Is the opcode that consumes \p use capable of forwarding guaranteed values?
+///
+/// This may be true even if \p use is not a ForwardingBorrow. If true, then the
+/// operation may be trivially rewritten with Guaranteed ownership.
+bool canOpcodeForwardGuaranteedValues(Operand *use);
+
+// This is the use-def equivalent of use->getOperandOwnership() ==
+// OperandOwnership::ForwardingBorrow.
+inline bool isForwardingBorrow(SILValue value) {
+  assert(value.getOwnershipKind() == OwnershipKind::Guaranteed);
+  return canOpcodeForwardGuaranteedValues(value);
+}
+
+/// Is the opcode that produces \p value capable of forwarding owned values?
+///
+/// This may be true even if the current instance of the instruction is not a
+/// ForwardingConsume. If true, then the operation may be trivially rewritten
+/// with Owned ownership.
+bool canOpcodeForwardOwnedValues(SILValue value);
 
-/// Is this value the result of an instruction that 'forward's owned ownership,
-/// but may not be able to forward guaranteed ownership.
+/// Is this opcode that consumes \p use capable of forwarding owned values?
 ///
-/// This will be either a multiple value instruction resuilt, a single value
-/// instruction that forwards or an argument that forwards the ownership from a
-/// previous terminator.
-bool isOwnedForwardingValue(SILValue value);
+/// This may be true even if the current instance of the instruction is not a
+/// ForwardingConsume. If true, then the operation may be trivially rewritten
+/// with Owned ownership.
+bool canOpcodeForwardOwnedValues(Operand *use);
+
+// This is the use-def equivalent of use->getOperandOwnership() ==
+// OperandOwnership::ForwardingConsume.
+inline bool isForwardingConsume(SILValue value) {
+  assert(value.getOwnershipKind() == OwnershipKind::Owned);
+  return canOpcodeForwardOwnedValues(value);
+}
 
 class ForwardingOperand {
   Operand *use;
@@ -225,25 +243,6 @@ struct BorrowingOperand {
     llvm_unreachable("Covered switch isn't covered?!");
   }
 
-  /// Is this a borrow scope operand that can open new borrow scopes
-  /// for owned values.
-  bool canAcceptOwnedValues() const {
-    switch (kind) {
-    // begin_borrow can take any parameter
-    case BorrowingOperandKind::BeginBorrow:
-    // Yield can implicit borrow owned values.
-    case BorrowingOperandKind::Yield:
-    // FullApplySites can implicit borrow owned values.
-    case BorrowingOperandKind::BeginApply:
-    case BorrowingOperandKind::Apply:
-    case BorrowingOperandKind::TryApply:
-      return true;
-    case BorrowingOperandKind::Branch:
-      return false;
-    }
-    llvm_unreachable("Covered switch isn't covered?!");
-  }
-
   /// Is the result of this instruction also a borrow introducer?
   ///
   /// TODO: This needs a better name.