Merge branch 'main' of github.com:apple/swift into tensorflow-stage

* 'main' of github.com:apple/swift:
  [ownership] Centralize all info about SILInstruction forwarding in the SILInstruction class hierarchy itself.
  [ownership] Assume values/operands in SILGlobalVariable blocks are not in OSSA.
  [sil] Templatize base class of FieldIndexCacheBase.
  [autodiff] Change getTangentStoredProperty() to use a Projection instead of FieldIndexCacheBase.

Author: ainu-bot

include/swift/Basic/InlineBitfield.h

@@ -81,6 +81,32 @@ namespace swift {
   LLVM_PACKED_END \
   static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
 
+/// Define a full bitfield for type 'T' that uses all of the remaining bits in
+/// the inline bitfield. We allow for 'T' to have a single generic parameter.
+///
+/// For optimal code gen, place naturally sized fields at the end, with the
+/// largest naturally sized field at the very end. For example:
+///
+/// SWIFT_INLINE_BITFIELD_FULL(Foo, Bar, 1+8+16,
+///   flag : 1,
+///   : NumPadBits, // pad the center, not the end
+///   x : 8,
+///   y : 16
+/// );
+///
+/// NOTE: All instances of Foo will access via the same bitfield entry even if
+/// they differ in the templated value!
+#define SWIFT_INLINE_BITFIELD_FULL_TEMPLATE(T, U, C, ...)                      \
+  LLVM_PACKED_START                                                            \
+  class T##Bitfield {                                                          \
+    template <typename TTy>                                                    \
+    friend class T;                                                            \
+    enum { NumPadBits = 64 - (Num##U##Bits + (C)) };                           \
+    uint64_t : Num##U##Bits, __VA_ARGS__;                                      \
+  } T;                                                                         \
+  LLVM_PACKED_END                                                              \
+  static_assert(sizeof(T##Bitfield) <= 8, "Bitfield overflow")
+
 /// Define an empty bitfield for type 'T'.
 #define SWIFT_INLINE_BITFIELD_EMPTY(T, U) \
   enum { Num##T##Bits = Num##U##Bits }

include/swift/SIL/OwnershipUtils.h

@@ -32,33 +32,22 @@ class DeadEndBlocks;
 /// Returns true if v is an address or trivial.
 bool isValueAddressOrTrivial(SILValue v);
 
-/// These operations forward both owned and guaranteed ownership.
-bool isOwnershipForwardingValueKind(SILNodeKind kind);
-
-/// Is this an operand that can forward both owned and guaranteed ownership
-/// kinds.
+/// 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 forwards guaranteed ownership from its value to a
-/// result of the using instruction.
+/// Is this an operand that can forward guaranteed ownership into one of the
+/// operand's owner instruction's result.
 bool isGuaranteedForwardingUse(Operand *op);
 
-/// These operations forward guaranteed ownership, but don't necessarily forward
-/// owned values.
-bool isGuaranteedForwardingValueKind(SILNodeKind kind);
+/// Is this an operand that can forward owned ownership into one of the
+/// operand's owner instruction's result.
+bool isOwnedForwardingUse(Operand *use);
 
-/// Is this a value that is the result of an operation that forwards owned
-/// ownership.
+/// 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 this a node kind that can forward owned ownership, but may not be able to
-/// forward guaranteed ownership.
-bool isOwnedForwardingValueKind(SILNodeKind kind);
-
-/// Does this operand 'forward' owned ownership, but may not be able to forward
-/// guaranteed ownership.
-bool isOwnedForwardingUse(Operand *use);
-
 /// Is this value the result of an instruction that 'forward's owned ownership,
 /// but may not be able to forward guaranteed ownership.
 ///
@@ -76,6 +65,11 @@ class ForwardingOperand {
   static Optional<ForwardingOperand> get(Operand *use);
 
   Operand *getUse() const { return use; }
+  OwnershipConstraint getOwnershipConstraint() const {
+    // We use a force unwrap since a ForwardingOperand should always have an
+    // ownership constraint.
+    return *use->getOwnershipConstraint();
+  }
   ValueOwnershipKind getOwnershipKind() const;
   void setOwnershipKind(ValueOwnershipKind newKind) const;
   void replaceOwnershipKind(ValueOwnershipKind oldKind,